From 0fb8e4116f72dcc07653097e3c641beb73ec17d9 Mon Sep 17 00:00:00 2001 From: Gareth Andrew Lloyd Date: Fri, 5 Jan 2024 16:42:54 +0000 Subject: [PATCH] Fix REPLICA timestamps (#1615) * Fix up REPLICA GetInfo and CreateSnapshot Subtle bug where these actions were using the incorrect transactional access while in REPLICA role. This casued timestamp to be incorrectly bumped, breaking REPLICA from doing replication. * Delay DNS resolution Rather than resolve at endpoint creation, we will instread resolve only on Socket connect. This allows k8s deployments to change their IP during pod restarts. * Minor sonarsource fixes --------- Co-authored-by: Andreja Co-authored-by: DavIvek --- include/mg_exceptions.hpp | 4 +- src/communication/client.cpp | 7 +- src/communication/http/session.hpp | 8 +- src/dbms/database.hpp | 10 +- src/dbms/dbms_handler.hpp | 8 +- src/dbms/inmemory/replication_handlers.cpp | 7 +- src/dbms/inmemory/storage_helper.hpp | 7 +- src/io/network/endpoint.cpp | 45 +--- src/io/network/socket.cpp | 27 ++- src/mg_import_csv.cpp | 8 +- src/query/interpreter.cpp | 22 +- src/query/stream/streams.cpp | 2 +- src/replication/include/replication/role.hpp | 5 +- src/storage/v2/disk/storage.cpp | 20 +- src/storage/v2/disk/storage.hpp | 16 +- src/storage/v2/inmemory/storage.cpp | 35 +-- src/storage/v2/inmemory/storage.hpp | 20 +- .../v2/replication/replication_client.hpp | 9 +- src/storage/v2/storage.cpp | 10 +- src/storage/v2/storage.hpp | 43 ++-- src/utils/algorithm.hpp | 7 +- src/utils/on_scope_exit.hpp | 7 +- tests/benchmark/query/eval.cpp | 7 +- tests/benchmark/query/execution.cpp | 34 +-- tests/benchmark/query/planner.cpp | 14 +- tests/benchmark/query/profile.cpp | 8 +- tests/benchmark/storage_v2_gc.cpp | 8 +- tests/benchmark/storage_v2_gc2.cpp | 8 +- tests/concurrent/storage_indices.cpp | 24 +- .../concurrent/storage_unique_constraints.cpp | 24 +- .../show_while_creating_invalid_state.py | 69 ++++++ tests/manual/query_planner.cpp | 6 +- tests/property_based/random_graph.cpp | 6 +- tests/unit/auth_checker.cpp | 6 +- tests/unit/bfs_fine_grained.cpp | 6 +- tests/unit/bfs_single_node.cpp | 6 +- tests/unit/bolt_encoder.cpp | 4 +- tests/unit/clearing_old_disk_data.cpp | 24 +- tests/unit/cpp_api.cpp | 4 +- tests/unit/database_get_info.cpp | 25 ++- tests/unit/plan_pretty_print.cpp | 4 +- tests/unit/query_cost_estimator.cpp | 10 +- tests/unit/query_dump.cpp | 70 +++--- tests/unit/query_expression_evaluator.cpp | 4 +- tests/unit/query_hint_provider.cpp | 4 +- .../unit/query_plan_accumulate_aggregate.cpp | 36 +-- tests/unit/query_plan_bag_semantics.cpp | 15 +- .../query_plan_create_set_remove_delete.cpp | 99 ++++---- tests/unit/query_plan_match_filter_return.cpp | 109 ++++----- tests/unit/query_plan_operator_to_string.cpp | 4 +- .../unit/query_plan_read_write_typecheck.cpp | 5 +- ...query_plan_v2_create_set_remove_delete.cpp | 17 +- tests/unit/query_pretty_print.cpp | 5 +- tests/unit/query_procedure_mgp_type.cpp | 10 +- tests/unit/query_procedure_py_module.cpp | 16 +- tests/unit/query_procedures_mgp_graph.cpp | 32 ++- tests/unit/query_semantic.cpp | 5 +- tests/unit/query_trigger.cpp | 8 +- tests/unit/query_variable_start_planner.cpp | 29 +-- tests/unit/storage_rocks.cpp | 8 +- tests/unit/storage_v2.cpp | 202 ++++++++--------- tests/unit/storage_v2_constraints.cpp | 156 ++++++------- tests/unit/storage_v2_durability_inmemory.cpp | 157 ++++++------- tests/unit/storage_v2_edge_inmemory.cpp | 211 ++++++++--------- tests/unit/storage_v2_edge_ondisk.cpp | 211 ++++++++--------- tests/unit/storage_v2_gc.cpp | 17 +- tests/unit/storage_v2_get_info.cpp | 30 +-- tests/unit/storage_v2_indices.cpp | 212 +++++++++--------- tests/unit/storage_v2_isolation_level.cpp | 11 +- tests/unit/storage_v2_replication.cpp | 28 +-- tests/unit/storage_v2_show_storage_info.cpp | 4 +- tests/unit/storage_v2_storage_mode.cpp | 6 +- tests/unit/typed_value.cpp | 5 +- 73 files changed, 1229 insertions(+), 1121 deletions(-) diff --git a/include/mg_exceptions.hpp b/include/mg_exceptions.hpp index 53a338b86..d526d4e43 100644 --- a/include/mg_exceptions.hpp +++ b/include/mg_exceptions.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -25,7 +25,7 @@ namespace mg_exception { template std::string StringSerialize(FirstArg &&firstArg, Args &&...args) { std::stringstream stream; - stream << firstArg; + stream << std::forward(firstArg); ((stream << " " << args), ...); return stream.str(); } diff --git a/src/communication/client.cpp b/src/communication/client.cpp index bd7fd6e7f..85c0d826a 100644 --- a/src/communication/client.cpp +++ b/src/communication/client.cpp @@ -1,4 +1,4 @@ -// Copyright 2022 Memgraph Ltd. +// Copyright 2024 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,6 +12,7 @@ #include "communication/client.hpp" #include "communication/helpers.hpp" +#include "io/network/network_error.hpp" #include "utils/logging.hpp" namespace memgraph::communication { @@ -25,7 +26,9 @@ Client::~Client() { bool Client::Connect(const io::network::Endpoint &endpoint) { // Try to establish a socket connection. - if (!socket_.Connect(endpoint)) return false; + if (!socket_.Connect(endpoint)) { + return false; + } // Enable TCP keep alive for all connections. // Because we manually always set the `have_more` flag to the socket diff --git a/src/communication/http/session.hpp b/src/communication/http/session.hpp index b08ce8f30..cef457065 100644 --- a/src/communication/http/session.hpp +++ b/src/communication/http/session.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -107,7 +107,7 @@ class Session : public std::enable_shared_from_this msg) { - ExecuteForStream([this, &msg](auto &&stream) { + ExecuteForStream([this, &msg](auto &stream) { // The lifetime of the message has to extend // for the duration of the async operation so // we use a shared_ptr to manage it. @@ -171,7 +171,7 @@ class Session : public std::enable_shared_from_this diff --git a/src/dbms/database.hpp b/src/dbms/database.hpp index 878fe7672..955c66998 100644 --- a/src/dbms/database.hpp +++ b/src/dbms/database.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -68,12 +68,12 @@ class Database { */ std::unique_ptr Access( std::optional override_isolation_level = {}) { - return storage_->Access(override_isolation_level, repl_state_->IsMain()); + return storage_->Access(repl_state_->GetRole(), override_isolation_level); } std::unique_ptr UniqueAccess( std::optional override_isolation_level = {}) { - return storage_->UniqueAccess(override_isolation_level, repl_state_->IsMain()); + return storage_->UniqueAccess(repl_state_->GetRole(), override_isolation_level); } /** @@ -103,9 +103,9 @@ class Database { * @param force_directory Use the configured directory, do not try to decipher the multi-db version * @return DatabaseInfo */ - DatabaseInfo GetInfo(bool force_directory = false) const { + DatabaseInfo GetInfo(bool force_directory, replication::ReplicationRole replication_role) const { DatabaseInfo info; - info.storage_info = storage_->GetInfo(force_directory); + info.storage_info = storage_->GetInfo(force_directory, replication_role); info.triggers = trigger_store_.GetTriggerInfo().size(); info.streams = streams_.GetStreamInfo().size(); return info; diff --git a/src/dbms/dbms_handler.hpp b/src/dbms/dbms_handler.hpp index 3151398ab..f9aa621dc 100644 --- a/src/dbms/dbms_handler.hpp +++ b/src/dbms/dbms_handler.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -232,6 +232,7 @@ class DbmsHandler { * @return Statistics */ Statistics Stats() { + auto const replication_role = repl_state_.GetRole(); Statistics stats{}; // TODO: Handle overflow? #ifdef MG_ENTERPRISE @@ -244,7 +245,7 @@ class DbmsHandler { auto db_acc_opt = db_gk.access(); if (db_acc_opt) { auto &db_acc = *db_acc_opt; - const auto &info = db_acc->GetInfo(); + const auto &info = db_acc->GetInfo(false, replication_role); const auto &storage_info = info.storage_info; stats.num_vertex += storage_info.vertex_count; stats.num_edges += storage_info.edge_count; @@ -268,6 +269,7 @@ class DbmsHandler { * @return std::vector */ std::vector Info() { + auto const replication_role = repl_state_.GetRole(); std::vector res; #ifdef MG_ENTERPRISE std::shared_lock rd(lock_); @@ -280,7 +282,7 @@ class DbmsHandler { auto db_acc_opt = db_gk.access(); if (db_acc_opt) { auto &db_acc = *db_acc_opt; - res.push_back(db_acc->GetInfo()); + res.push_back(db_acc->GetInfo(false, replication_role)); } } return res; diff --git a/src/dbms/inmemory/replication_handlers.cpp b/src/dbms/inmemory/replication_handlers.cpp index 5eba61878..2b8d6a86b 100644 --- a/src/dbms/inmemory/replication_handlers.cpp +++ b/src/dbms/inmemory/replication_handlers.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +22,7 @@ #include "storage/v2/inmemory/storage.hpp" #include "storage/v2/inmemory/unique_constraints.hpp" +using memgraph::replication::ReplicationRole; using memgraph::storage::Delta; using memgraph::storage::EdgeAccessor; using memgraph::storage::EdgeRef; @@ -380,9 +381,9 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage if (!commit_timestamp_and_accessor) { std::unique_ptr acc = nullptr; if (unique) { - acc = storage->UniqueAccess(std::nullopt, false /*not main*/); + acc = storage->UniqueAccess(ReplicationRole::REPLICA); } else { - acc = storage->Access(std::nullopt, false /*not main*/); + acc = storage->Access(ReplicationRole::REPLICA); } auto inmem_acc = std::unique_ptr( static_cast(acc.release())); diff --git a/src/dbms/inmemory/storage_helper.hpp b/src/dbms/inmemory/storage_helper.hpp index 1cd9f9f4e..8e38f0a0f 100644 --- a/src/dbms/inmemory/storage_helper.hpp +++ b/src/dbms/inmemory/storage_helper.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -31,10 +31,7 @@ inline std::unique_ptr CreateInMemoryStorage(storage::Config c // Connect replication state and storage storage->CreateSnapshotHandler( [storage = storage.get(), &repl_state]() -> utils::BasicResult { - if (repl_state.IsReplica()) { - return storage::InMemoryStorage::CreateSnapshotError::DisabledForReplica; - } - return storage->CreateSnapshot(); + return storage->CreateSnapshot(repl_state.GetRole()); }); if (allow_mt_repl || name == dbms::kDefaultDB) { diff --git a/src/io/network/endpoint.cpp b/src/io/network/endpoint.cpp index e719180f5..5e671ef38 100644 --- a/src/io/network/endpoint.cpp +++ b/src/io/network/endpoint.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -139,18 +139,13 @@ Endpoint::Endpoint(std::string ip_address, uint16_t port) : address(std::move(ip } // NOLINTNEXTLINE -Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port) : port(port) { - address = ResolveHostnameIntoIpAddress(hostname, port); - IpFamily ip_family = GetIpFamily(address); - if (ip_family == IpFamily::NONE) { - throw NetworkError("Not a valid IPv4 or IPv6 address: {}", address); - } - family = ip_family; -} +Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port) + : address(std::move(hostname)), port(port), family{GetIpFamily(address)} {} std::ostream &operator<<(std::ostream &os, const Endpoint &endpoint) { // no need to cover the IpFamily::NONE case, as you can't even construct an // Endpoint object if the IpFamily is NONE (i.e. the IP address is invalid) + // unless you use DNS hostname if (endpoint.family == Endpoint::IpFamily::IP6) { return os << "[" << endpoint.address << "]" << ":" << endpoint.port; @@ -166,7 +161,7 @@ bool Endpoint::IsResolvableAddress(const std::string &address, uint16_t port) { }; addrinfo *info = nullptr; auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info); - freeaddrinfo(info); + if (info) freeaddrinfo(info); return status == 0; } @@ -189,34 +184,4 @@ std::optional> Endpoint::ParseSocketOrAddress( return std::nullopt; } -std::string Endpoint::ResolveHostnameIntoIpAddress(const std::string &address, uint16_t port) { - addrinfo hints{ - .ai_flags = AI_PASSIVE, - .ai_family = AF_UNSPEC, // IPv4 and IPv6 - .ai_socktype = SOCK_STREAM // TCP socket - }; - addrinfo *info = nullptr; - auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info); - if (status != 0) throw NetworkError(gai_strerror(status)); - - for (auto *result = info; result != nullptr; result = result->ai_next) { - if (result->ai_family == AF_INET) { - char ipstr[INET_ADDRSTRLEN]; - auto *ipv4 = reinterpret_cast(result->ai_addr); - inet_ntop(AF_INET, &(ipv4->sin_addr), ipstr, sizeof(ipstr)); - freeaddrinfo(info); - return ipstr; - } - if (result->ai_family == AF_INET6) { - char ipstr[INET6_ADDRSTRLEN]; - auto *ipv6 = reinterpret_cast(result->ai_addr); - inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipstr, sizeof(ipstr)); - freeaddrinfo(info); - return ipstr; - } - } - freeaddrinfo(info); - throw NetworkError("Not a valid address: {}", address); -} - } // namespace memgraph::io::network diff --git a/src/io/network/socket.cpp b/src/io/network/socket.cpp index 7394ea39d..2d949cd4d 100644 --- a/src/io/network/socket.cpp +++ b/src/io/network/socket.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -15,6 +15,7 @@ #include #include "io/network/addrinfo.hpp" +#include "io/network/network_error.hpp" #include "io/network/socket.hpp" #include "utils/likely.hpp" #include "utils/logging.hpp" @@ -55,17 +56,21 @@ bool Socket::IsOpen() const { return socket_ != -1; } bool Socket::Connect(const Endpoint &endpoint) { if (socket_ != -1) return false; - for (const auto &it : AddrInfo{endpoint}) { - int sfd = socket(it.ai_family, it.ai_socktype, it.ai_protocol); - if (sfd == -1) continue; - if (connect(sfd, it.ai_addr, it.ai_addrlen) == 0) { - socket_ = sfd; - endpoint_ = endpoint; - break; + try { + for (const auto &it : AddrInfo{endpoint}) { + int sfd = socket(it.ai_family, it.ai_socktype, it.ai_protocol); + if (sfd == -1) continue; + if (connect(sfd, it.ai_addr, it.ai_addrlen) == 0) { + socket_ = sfd; + endpoint_ = endpoint; + break; + } + // If the connect failed close the file descriptor to prevent file + // descriptors being leaked + close(sfd); } - // If the connect failed close the file descriptor to prevent file - // descriptors being leaked - close(sfd); + } catch (const NetworkError &e) { + return false; } return !(socket_ == -1); diff --git a/src/mg_import_csv.cpp b/src/mg_import_csv.cpp index e0a82584b..e8212b5f4 100644 --- a/src/mg_import_csv.cpp +++ b/src/mg_import_csv.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -32,6 +32,8 @@ #include "utils/timer.hpp" #include "version.hpp" +using memgraph::replication::ReplicationRole; + bool ValidateControlCharacter(const char *flagname, const std::string &value) { if (value.empty()) { printf("The argument '%s' cannot be empty\n", flagname); @@ -425,7 +427,7 @@ void ProcessNodeRow(memgraph::storage::Storage *store, const std::vector &fields, const std::vector &additional_labels, std::unordered_map *node_id_map) { std::optional id; - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto node = acc->CreateVertex(); for (size_t i = 0; i < row.size(); ++i) { const auto &field = fields[i]; @@ -571,7 +573,7 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto if (!end_id) throw LoadException("END_ID must be set"); if (!relationship_type) throw LoadException("Relationship TYPE must be set"); - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto from_node = acc->FindVertex(*start_id, memgraph::storage::View::NEW); if (!from_node) throw LoadException("From node must be in the storage"); auto to_node = acc->FindVertex(*end_id, memgraph::storage::View::NEW); diff --git a/src/query/interpreter.cpp b/src/query/interpreter.cpp index 7292c4591..9731c3484 100644 --- a/src/query/interpreter.cpp +++ b/src/query/interpreter.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -2786,8 +2786,8 @@ PreparedQuery PrepareEdgeImportModeQuery(ParsedQuery parsed_query, CurrentDB &cu RWType::NONE}; } -PreparedQuery PrepareCreateSnapshotQuery(ParsedQuery parsed_query, bool in_explicit_transaction, - CurrentDB ¤t_db) { +PreparedQuery PrepareCreateSnapshotQuery(ParsedQuery parsed_query, bool in_explicit_transaction, CurrentDB ¤t_db, + replication::ReplicationRole replication_role) { if (in_explicit_transaction) { throw CreateSnapshotInMulticommandTxException(); } @@ -2802,9 +2802,10 @@ PreparedQuery PrepareCreateSnapshotQuery(ParsedQuery parsed_query, bool in_expli return PreparedQuery{ {}, std::move(parsed_query.required_privileges), - [storage](AnyStream * /*stream*/, std::optional /*n*/) -> std::optional { + [storage, replication_role](AnyStream * /*stream*/, + std::optional /*n*/) -> std::optional { auto *mem_storage = static_cast(storage); - if (auto maybe_error = mem_storage->CreateSnapshot(); maybe_error.HasError()) { + if (auto maybe_error = mem_storage->CreateSnapshot(replication_role); maybe_error.HasError()) { switch (maybe_error.GetError()) { case storage::InMemoryStorage::CreateSnapshotError::DisabledForReplica: throw utils::BasicException( @@ -2977,15 +2978,16 @@ PreparedQuery PrepareDatabaseInfoQuery(ParsedQuery parsed_query, bool in_explici auto *info_query = utils::Downcast(parsed_query.query); std::vector header; std::function>, QueryHandlerResult>()> handler; - + auto *database = current_db.db_acc_->get(); switch (info_query->info_type_) { case DatabaseInfoQuery::InfoType::INDEX: { header = {"index type", "label", "property", "count"}; - handler = [storage = current_db.db_acc_->get()->storage(), dba] { + handler = [database, dba] { + auto *storage = database->storage(); const std::string_view label_index_mark{"label"}; const std::string_view label_property_index_mark{"label+property"}; auto info = dba->ListAllIndices(); - auto storage_acc = storage->Access(); + auto storage_acc = database->Access(); std::vector> results; results.reserve(info.label.size() + info.label_property.size()); for (const auto &item : info.label) { @@ -3823,7 +3825,9 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string, } else if (utils::Downcast(parsed_query.query)) { prepared_query = PrepareIsolationLevelQuery(std::move(parsed_query), in_explicit_transaction_, current_db_, this); } else if (utils::Downcast(parsed_query.query)) { - prepared_query = PrepareCreateSnapshotQuery(std::move(parsed_query), in_explicit_transaction_, current_db_); + auto const replication_role = interpreter_context_->repl_state->GetRole(); + prepared_query = + PrepareCreateSnapshotQuery(std::move(parsed_query), in_explicit_transaction_, current_db_, replication_role); } else if (utils::Downcast(parsed_query.query)) { /// SYSTEM PURE prepared_query = PrepareSettingQuery(std::move(parsed_query), in_explicit_transaction_); diff --git a/src/query/stream/streams.cpp b/src/query/stream/streams.cpp index 896607e94..57011aecb 100644 --- a/src/query/stream/streams.cpp +++ b/src/query/stream/streams.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 diff --git a/src/replication/include/replication/role.hpp b/src/replication/include/replication/role.hpp index 54fbab9f0..bb720f8e0 100644 --- a/src/replication/include/replication/role.hpp +++ b/src/replication/include/replication/role.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,5 +14,6 @@ #include namespace memgraph::replication { +// TODO: figure out a way of ensuring that usage of this type is never uninitialed/defaulted incorrectly to MAIN enum class ReplicationRole : uint8_t { MAIN, REPLICA }; -} +} // namespace memgraph::replication diff --git a/src/storage/v2/disk/storage.cpp b/src/storage/v2/disk/storage.cpp index 3f0ab9572..ef182b439 100644 --- a/src/storage/v2/disk/storage.cpp +++ b/src/storage/v2/disk/storage.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -288,7 +288,7 @@ DiskStorage::~DiskStorage() { DiskStorage::DiskAccessor::DiskAccessor(auto tag, DiskStorage *storage, IsolationLevel isolation_level, StorageMode storage_mode) - : Accessor(tag, storage, isolation_level, storage_mode) { + : Accessor(tag, storage, isolation_level, storage_mode, memgraph::replication::ReplicationRole::MAIN) { rocksdb::WriteOptions write_options; auto txOptions = rocksdb::TransactionOptions{.set_snapshot = true}; transaction_.disk_transaction_ = storage->kvstore_->db_->BeginTransaction(write_options, txOptions); @@ -837,10 +837,10 @@ StorageInfo DiskStorage::GetBaseInfo(bool /* unused */) { return info; } -StorageInfo DiskStorage::GetInfo(bool force_dir) { +StorageInfo DiskStorage::GetInfo(bool force_dir, memgraph::replication::ReplicationRole replication_role) { StorageInfo info = GetBaseInfo(force_dir); { - auto access = Access(std::nullopt); + auto access = Access(replication_role); const auto &lbl = access->ListAllIndices(); info.label_indices = lbl.label.size(); info.label_property_indices = lbl.label_property.size(); @@ -2005,7 +2005,8 @@ UniqueConstraints::DeletionStatus DiskStorage::DiskAccessor::DropUniqueConstrain return UniqueConstraints::DeletionStatus::SUCCESS; } -Transaction DiskStorage::CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, bool /*is_main*/) { +Transaction DiskStorage::CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, + memgraph::replication::ReplicationRole /*is_main*/) { /// We acquire the transaction engine lock here because we access (and /// modify) the transaction engine variables (`transaction_id` and /// `timestamp`) below. @@ -2030,8 +2031,8 @@ uint64_t DiskStorage::CommitTimestamp(const std::optional desired_comm return *desired_commit_timestamp; } -std::unique_ptr DiskStorage::Access(std::optional override_isolation_level, - bool /*is_main*/) { +std::unique_ptr DiskStorage::Access(memgraph::replication::ReplicationRole /*replication_role*/, + std::optional override_isolation_level) { auto isolation_level = override_isolation_level.value_or(isolation_level_); if (isolation_level != IsolationLevel::SNAPSHOT_ISOLATION) { throw utils::NotYetImplemented("Disk storage supports only SNAPSHOT isolation level."); @@ -2039,8 +2040,9 @@ std::unique_ptr DiskStorage::Access(std::optional( new DiskAccessor{Storage::Accessor::shared_access, this, isolation_level, storage_mode_}); } -std::unique_ptr DiskStorage::UniqueAccess(std::optional override_isolation_level, - bool /*is_main*/) { +std::unique_ptr DiskStorage::UniqueAccess( + memgraph::replication::ReplicationRole /*replication_role*/, + std::optional override_isolation_level) { auto isolation_level = override_isolation_level.value_or(isolation_level_); if (isolation_level != IsolationLevel::SNAPSHOT_ISOLATION) { throw utils::NotYetImplemented("Disk storage supports only SNAPSHOT isolation level."); diff --git a/src/storage/v2/disk/storage.hpp b/src/storage/v2/disk/storage.hpp index 8640462de..219cb8272 100644 --- a/src/storage/v2/disk/storage.hpp +++ b/src/storage/v2/disk/storage.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -176,12 +176,12 @@ class DiskStorage final : public Storage { }; using Storage::Access; - std::unique_ptr Access(std::optional override_isolation_level, - bool is_main) override; + std::unique_ptr Access(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) override; using Storage::UniqueAccess; - std::unique_ptr UniqueAccess(std::optional override_isolation_level, - bool is_main) override; + std::unique_ptr UniqueAccess(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) override; /// Flushing methods [[nodiscard]] utils::BasicResult FlushIndexCache(Transaction *transaction); @@ -284,8 +284,8 @@ class DiskStorage final : public Storage { RocksDBStorage *GetRocksDBStorage() const { return kvstore_.get(); } - using Storage::CreateTransaction; - Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, bool is_main) override; + Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, + memgraph::replication::ReplicationRole replication_role) override; void SetEdgeImportMode(EdgeImportMode edge_import_status); @@ -308,7 +308,7 @@ class DiskStorage final : public Storage { PropertyId property); StorageInfo GetBaseInfo(bool force_directory) override; - StorageInfo GetInfo(bool force_directory) override; + StorageInfo GetInfo(bool force_directory, memgraph::replication::ReplicationRole replication_role) override; void FreeMemory(std::unique_lock /*lock*/) override {} diff --git a/src/storage/v2/inmemory/storage.cpp b/src/storage/v2/inmemory/storage.cpp index 988c36acd..6eeefb3ce 100644 --- a/src/storage/v2/inmemory/storage.cpp +++ b/src/storage/v2/inmemory/storage.cpp @@ -175,8 +175,9 @@ InMemoryStorage::~InMemoryStorage() { } InMemoryStorage::InMemoryAccessor::InMemoryAccessor(auto tag, InMemoryStorage *storage, IsolationLevel isolation_level, - StorageMode storage_mode, bool is_main) - : Accessor(tag, storage, isolation_level, storage_mode, is_main), config_(storage->config_.items) {} + StorageMode storage_mode, + memgraph::replication::ReplicationRole replication_role) + : Accessor(tag, storage, isolation_level, storage_mode, replication_role), config_(storage->config_.items) {} InMemoryStorage::InMemoryAccessor::InMemoryAccessor(InMemoryAccessor &&other) noexcept : Accessor(std::move(other)), config_(other.config_) {} @@ -1301,7 +1302,8 @@ VerticesIterable InMemoryStorage::InMemoryAccessor::Vertices( mem_label_property_index->Vertices(label, property, lower_bound, upper_bound, view, storage_, &transaction_)); } -Transaction InMemoryStorage::CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, bool is_main) { +Transaction InMemoryStorage::CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, + memgraph::replication::ReplicationRole replication_role) { // We acquire the transaction engine lock here because we access (and // modify) the transaction engine variables (`transaction_id` and // `timestamp`) below. @@ -1316,7 +1318,7 @@ Transaction InMemoryStorage::CreateTransaction(IsolationLevel isolation_level, S // of any query on replica to the last commited transaction // which is timestamp_ as only commit of transaction with writes // can change the value of it. - if (is_main) { + if (replication_role == memgraph::replication::ReplicationRole::MAIN) { start_timestamp = timestamp_++; } else { start_timestamp = timestamp_; @@ -1700,10 +1702,10 @@ StorageInfo InMemoryStorage::GetBaseInfo(bool force_directory) { return info; } -StorageInfo InMemoryStorage::GetInfo(bool force_directory) { +StorageInfo InMemoryStorage::GetInfo(bool force_directory, memgraph::replication::ReplicationRole replication_role) { StorageInfo info = GetBaseInfo(force_directory); { - auto access = Access(std::nullopt); + auto access = Access(replication_role); // TODO: override isolation level? const auto &lbl = access->ListAllIndices(); info.label_indices = lbl.label.size(); info.label_property_indices = lbl.label_property.size(); @@ -2030,11 +2032,16 @@ void InMemoryStorage::AppendToWalDataDefinition(durability::StorageMetadataOpera return AppendToWalDataDefinition(operation, label, {}, {}, final_commit_timestamp); } -utils::BasicResult InMemoryStorage::CreateSnapshot() { +utils::BasicResult InMemoryStorage::CreateSnapshot( + memgraph::replication::ReplicationRole replication_role) { + if (replication_role == memgraph::replication::ReplicationRole::REPLICA) { + return InMemoryStorage::CreateSnapshotError::DisabledForReplica; + } auto const &epoch = repl_storage_state_.epoch_; auto snapshot_creator = [this, &epoch]() { utils::Timer timer; - auto transaction = CreateTransaction(IsolationLevel::SNAPSHOT_ISOLATION, storage_mode_); + auto transaction = CreateTransaction(IsolationLevel::SNAPSHOT_ISOLATION, storage_mode_, + memgraph::replication::ReplicationRole::MAIN); durability::CreateSnapshot(this, &transaction, recovery_.snapshot_directory_, recovery_.wal_directory_, &vertices_, &edges_, uuid_, epoch, repl_storage_state_.history, &file_retainer_); // Finalize snapshot transaction. @@ -2122,17 +2129,17 @@ utils::FileRetainer::FileLockerAccessor::ret_type InMemoryStorage::UnlockPath() return true; } -std::unique_ptr InMemoryStorage::Access(std::optional override_isolation_level, - bool is_main) { +std::unique_ptr InMemoryStorage::Access(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) { return std::unique_ptr(new InMemoryAccessor{Storage::Accessor::shared_access, this, override_isolation_level.value_or(isolation_level_), - storage_mode_, is_main}); + storage_mode_, replication_role}); } -std::unique_ptr InMemoryStorage::UniqueAccess(std::optional override_isolation_level, - bool is_main) { +std::unique_ptr InMemoryStorage::UniqueAccess( + memgraph::replication::ReplicationRole replication_role, std::optional override_isolation_level) { return std::unique_ptr(new InMemoryAccessor{Storage::Accessor::unique_access, this, override_isolation_level.value_or(isolation_level_), - storage_mode_, is_main}); + storage_mode_, replication_role}); } void InMemoryStorage::CreateSnapshotHandler( diff --git a/src/storage/v2/inmemory/storage.hpp b/src/storage/v2/inmemory/storage.hpp index b0a7236a0..45d0f270f 100644 --- a/src/storage/v2/inmemory/storage.hpp +++ b/src/storage/v2/inmemory/storage.hpp @@ -73,7 +73,7 @@ class InMemoryStorage final : public Storage { friend class InMemoryStorage; explicit InMemoryAccessor(auto tag, InMemoryStorage *storage, IsolationLevel isolation_level, - StorageMode storage_mode, bool is_main = true); + StorageMode storage_mode, memgraph::replication::ReplicationRole replication_role); public: InMemoryAccessor(const InMemoryAccessor &) = delete; @@ -322,12 +322,11 @@ class InMemoryStorage final : public Storage { }; using Storage::Access; - std::unique_ptr Access(std::optional override_isolation_level, - bool is_main) override; - + std::unique_ptr Access(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) override; using Storage::UniqueAccess; - std::unique_ptr UniqueAccess(std::optional override_isolation_level, - bool is_main) override; + std::unique_ptr UniqueAccess(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) override; void FreeMemory(std::unique_lock main_guard) override; @@ -335,12 +334,13 @@ class InMemoryStorage final : public Storage { utils::FileRetainer::FileLockerAccessor::ret_type LockPath(); utils::FileRetainer::FileLockerAccessor::ret_type UnlockPath(); - utils::BasicResult CreateSnapshot(); + utils::BasicResult CreateSnapshot( + memgraph::replication::ReplicationRole replication_role); void CreateSnapshotHandler(std::function()> cb); - using Storage::CreateTransaction; - Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, bool is_main) override; + Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, + memgraph::replication::ReplicationRole replication_role) override; void SetStorageMode(StorageMode storage_mode); @@ -365,7 +365,7 @@ class InMemoryStorage final : public Storage { void FinalizeWalFile(); StorageInfo GetBaseInfo(bool force_directory) override; - StorageInfo GetInfo(bool force_directory) override; + StorageInfo GetInfo(bool force_directory, memgraph::replication::ReplicationRole replication_role) override; /// Return true in all cases excepted if any sync replicas have not sent confirmation. [[nodiscard]] bool AppendToWalDataManipulation(const Transaction &transaction, uint64_t final_commit_timestamp); diff --git a/src/storage/v2/replication/replication_client.hpp b/src/storage/v2/replication/replication_client.hpp index 3d2c019e9..4ef00f623 100644 --- a/src/storage/v2/replication/replication_client.hpp +++ b/src/storage/v2/replication/replication_client.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -117,11 +117,14 @@ class ReplicationStorageClient { if (State() != replication::ReplicaState::REPLICATING) { return; } - if (replica_stream_->IsDefunct()) return; + if (!replica_stream_ || replica_stream_->IsDefunct()) { + replica_state_.WithLock([](auto &state) { state = replication::ReplicaState::MAYBE_BEHIND; }); + return; + } try { callback(*replica_stream_); // failure state what if not streaming (std::nullopt) } catch (const rpc::RpcFailedException &) { - return replica_state_.WithLock([](auto &state) { state = replication::ReplicaState::MAYBE_BEHIND; }); + replica_state_.WithLock([](auto &state) { state = replication::ReplicaState::MAYBE_BEHIND; }); LogRpcFailure(); } } diff --git a/src/storage/v2/storage.cpp b/src/storage/v2/storage.cpp index ed3847314..52dcad243 100644 --- a/src/storage/v2/storage.cpp +++ b/src/storage/v2/storage.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -50,26 +50,26 @@ Storage::Storage(Config config, StorageMode storage_mode) } Storage::Accessor::Accessor(SharedAccess /* tag */, Storage *storage, IsolationLevel isolation_level, - StorageMode storage_mode, bool is_main) + StorageMode storage_mode, memgraph::replication::ReplicationRole replication_role) : storage_(storage), // The lock must be acquired before creating the transaction object to // prevent freshly created transactions from dangling in an active state // during exclusive operations. storage_guard_(storage_->main_lock_), unique_guard_(storage_->main_lock_, std::defer_lock), - transaction_(storage->CreateTransaction(isolation_level, storage_mode, is_main)), + transaction_(storage->CreateTransaction(isolation_level, storage_mode, replication_role)), is_transaction_active_(true), creation_storage_mode_(storage_mode) {} Storage::Accessor::Accessor(UniqueAccess /* tag */, Storage *storage, IsolationLevel isolation_level, - StorageMode storage_mode, bool is_main) + StorageMode storage_mode, memgraph::replication::ReplicationRole replication_role) : storage_(storage), // The lock must be acquired before creating the transaction object to // prevent freshly created transactions from dangling in an active state // during exclusive operations. storage_guard_(storage_->main_lock_, std::defer_lock), unique_guard_(storage_->main_lock_), - transaction_(storage->CreateTransaction(isolation_level, storage_mode, is_main)), + transaction_(storage->CreateTransaction(isolation_level, storage_mode, replication_role)), is_transaction_active_(true), creation_storage_mode_(storage_mode) {} diff --git a/src/storage/v2/storage.hpp b/src/storage/v2/storage.hpp index bf1973bcd..cf93ae3d9 100644 --- a/src/storage/v2/storage.hpp +++ b/src/storage/v2/storage.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -132,9 +132,9 @@ class Storage { } unique_access; Accessor(SharedAccess /* tag */, Storage *storage, IsolationLevel isolation_level, StorageMode storage_mode, - bool is_main = true); + memgraph::replication::ReplicationRole replication_role); Accessor(UniqueAccess /* tag */, Storage *storage, IsolationLevel isolation_level, StorageMode storage_mode, - bool is_main = true); + memgraph::replication::ReplicationRole replication_role); Accessor(const Accessor &) = delete; Accessor &operator=(const Accessor &) = delete; Accessor &operator=(Accessor &&other) = delete; @@ -315,19 +315,17 @@ class Storage { void FreeMemory() { FreeMemory({}); } - virtual std::unique_ptr Access(std::optional override_isolation_level, bool is_main) = 0; - std::unique_ptr Access(bool is_main = true) { return Access(std::optional{}, is_main); } - std::unique_ptr Access(std::optional override_isolation_level) { - return Access(std::move(override_isolation_level), true); + virtual std::unique_ptr Access(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) = 0; + + std::unique_ptr Access(memgraph::replication::ReplicationRole replication_role) { + return Access(replication_role, {}); } - virtual std::unique_ptr UniqueAccess(std::optional override_isolation_level, - bool is_main) = 0; - std::unique_ptr UniqueAccess(bool is_main = true) { - return UniqueAccess(std::optional{}, is_main); - } - std::unique_ptr UniqueAccess(std::optional override_isolation_level) { - return UniqueAccess(std::move(override_isolation_level), true); + virtual std::unique_ptr UniqueAccess(memgraph::replication::ReplicationRole replication_role, + std::optional override_isolation_level) = 0; + std::unique_ptr UniqueAccess(memgraph::replication::ReplicationRole replication_role) { + return UniqueAccess(replication_role, {}); } enum class SetIsolationLevelError : uint8_t { DisabledForAnalyticalMode }; @@ -345,21 +343,10 @@ class Storage { return GetBaseInfo(force_dir); } - virtual StorageInfo GetInfo(bool force_directory) = 0; - StorageInfo GetInfo() { -#if MG_ENTERPRISE - const bool force_dir = false; -#else - const bool force_dir = true; //!< Use the configured directory (multi-tenancy reroutes to another dir) -#endif - return GetInfo(force_dir); - } + virtual StorageInfo GetInfo(bool force_directory, memgraph::replication::ReplicationRole replication_role) = 0; - Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode) { - return CreateTransaction(isolation_level, storage_mode, true); - } - - virtual Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, bool is_main) = 0; + virtual Transaction CreateTransaction(IsolationLevel isolation_level, StorageMode storage_mode, + memgraph::replication::ReplicationRole replication_role) = 0; virtual void PrepareForNewEpoch() = 0; diff --git a/src/utils/algorithm.hpp b/src/utils/algorithm.hpp index cac7ccc9b..fc34e9a4d 100644 --- a/src/utils/algorithm.hpp +++ b/src/utils/algorithm.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -68,7 +68,7 @@ inline std::string IterableToString(const TIterable &iterable, const std::string */ template inline std::string IterableToString(const TIterable &iterable, const std::string_view delim = ", ") { - return IterableToString(iterable, delim, [](const auto &item) { return item; }); + return IterableToString(iterable, delim, std::identity{}); } /** @@ -216,8 +216,7 @@ TCollection Reversed(const TCollection &collection, const TAllocator &alloc) { template class Iterable { public: - Iterable(TIterator &&begin, TIterator &&end) - : begin_(std::forward(begin)), end_(std::forward(end)) {} + Iterable(TIterator &&begin, TIterator &&end) : begin_(std::move(begin)), end_(std::move(end)) {} auto begin() { return begin_; }; auto end() { return end_; }; diff --git a/src/utils/on_scope_exit.hpp b/src/utils/on_scope_exit.hpp index 70aec52b6..1c0b34fef 100644 --- a/src/utils/on_scope_exit.hpp +++ b/src/utils/on_scope_exit.hpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 #include namespace memgraph::utils { @@ -37,7 +38,9 @@ namespace memgraph::utils { template class [[nodiscard]] OnScopeExit { public: - explicit OnScopeExit(Callable &&function) : function_{std::forward(function)}, doCall_{true} {} + template + requires std::constructible_from + explicit OnScopeExit(U &&function) : function_{std::forward(function)}, doCall_{true} {} OnScopeExit(OnScopeExit const &) = delete; OnScopeExit(OnScopeExit &&) = delete; OnScopeExit &operator=(OnScopeExit const &) = delete; diff --git a/tests/benchmark/query/eval.cpp b/tests/benchmark/query/eval.cpp index 5e5acea7f..09e789137 100644 --- a/tests/benchmark/query/eval.cpp +++ b/tests/benchmark/query/eval.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +17,7 @@ #include "storage/v2/inmemory/storage.hpp" #include "storage/v2/storage.hpp" +using memgraph::replication::ReplicationRole; // The following classes are wrappers for memgraph::utils::MemoryResource, so that we can // use BENCHMARK_TEMPLATE @@ -40,7 +41,7 @@ static void MapLiteral(benchmark::State &state) { TMemory memory; memgraph::query::Frame frame(symbol_table.max_position(), memory.get()); std::unique_ptr db(new memgraph::storage::InMemoryStorage()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); std::unordered_map elements; for (int64_t i = 0; i < state.range(0); ++i) { @@ -71,7 +72,7 @@ static void AdditionOperator(benchmark::State &state) { TMemory memory; memgraph::query::Frame frame(symbol_table.max_position(), memory.get()); std::unique_ptr db(new memgraph::storage::InMemoryStorage()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); memgraph::query::Expression *expr = ast.Create(0); for (int64_t i = 0; i < state.range(0); ++i) { diff --git a/tests/benchmark/query/execution.cpp b/tests/benchmark/query/execution.cpp index 771f0ac1f..aa72e21d7 100644 --- a/tests/benchmark/query/execution.cpp +++ b/tests/benchmark/query/execution.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -32,6 +32,8 @@ #include "query/interpreter.hpp" #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; + // The following classes are wrappers for memgraph::utils::MemoryResource, so that we can // use BENCHMARK_TEMPLATE @@ -61,7 +63,7 @@ class PoolResource final { }; static void AddVertices(memgraph::storage::Storage *db, int vertex_count) { - auto dba = db->Access(); + auto dba = db->Access(ReplicationRole::MAIN); for (int i = 0; i < vertex_count; i++) dba->CreateVertex(); MG_ASSERT(!dba->Commit().HasError()); } @@ -70,7 +72,7 @@ static const char *kStartLabel = "start"; static void AddStarGraph(memgraph::storage::Storage *db, int spoke_count, int depth) { { - auto dba = db->Access(); + auto dba = db->Access(ReplicationRole::MAIN); auto center_vertex = dba->CreateVertex(); MG_ASSERT(center_vertex.AddLabel(dba->NameToLabel(kStartLabel)).HasValue()); for (int i = 0; i < spoke_count; ++i) { @@ -84,14 +86,14 @@ static void AddStarGraph(memgraph::storage::Storage *db, int spoke_count, int de MG_ASSERT(!dba->Commit().HasError()); } { - auto unique_acc = db->UniqueAccess(); + auto unique_acc = db->UniqueAccess(ReplicationRole::MAIN); MG_ASSERT(!unique_acc->CreateIndex(db->NameToLabel(kStartLabel)).HasError()); } } static void AddTree(memgraph::storage::Storage *db, int vertex_count) { { - auto dba = db->Access(); + auto dba = db->Access(ReplicationRole::MAIN); std::vector vertices; vertices.reserve(vertex_count); auto root = dba->CreateVertex(); @@ -109,7 +111,7 @@ static void AddTree(memgraph::storage::Storage *db, int vertex_count) { MG_ASSERT(!dba->Commit().HasError()); } { - auto unique_acc = db->UniqueAccess(); + auto unique_acc = db->UniqueAccess(ReplicationRole::MAIN); MG_ASSERT(!unique_acc->CreateIndex(db->NameToLabel(kStartLabel)).HasError()); } } @@ -132,7 +134,7 @@ static void Distinct(benchmark::State &state) { memgraph::query::Parameters parameters; std::unique_ptr db(new memgraph::storage::InMemoryStorage()); AddVertices(db.get(), state.range(0)); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto query_string = "MATCH (s) RETURN DISTINCT s"; auto *cypher_query = ParseCypherQuery(query_string, &ast); @@ -185,7 +187,7 @@ static void ExpandVariable(benchmark::State &state) { AddStarGraph(db.get(), state.range(0), state.range(1)); memgraph::query::SymbolTable symbol_table; auto expand_variable = MakeExpandVariable(memgraph::query::EdgeAtom::Type::DEPTH_FIRST, &symbol_table); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -225,7 +227,7 @@ static void ExpandBfs(benchmark::State &state) { AddTree(db.get(), state.range(0)); memgraph::query::SymbolTable symbol_table; auto expand_variable = MakeExpandVariable(memgraph::query::EdgeAtom::Type::BREADTH_FIRST, &symbol_table); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -261,7 +263,7 @@ static void ExpandShortest(benchmark::State &state) { auto expand_variable = MakeExpandVariable(memgraph::query::EdgeAtom::Type::BREADTH_FIRST, &symbol_table); expand_variable.common_.existing_node = true; auto dest_symbol = expand_variable.common_.node_symbol; - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -303,7 +305,7 @@ static void ExpandWeightedShortest(benchmark::State &state) { symbol_table.CreateSymbol("edge", false), symbol_table.CreateSymbol("vertex", false), ast.Create(1)}; auto dest_symbol = expand_variable.common_.node_symbol; - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -349,7 +351,7 @@ static void Accumulate(benchmark::State &state) { } memgraph::query::plan::Accumulate accumulate(scan_all, symbols, /* advance_command= */ false); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -399,7 +401,7 @@ static void Aggregate(benchmark::State &state) { symbol_table.CreateSymbol("out" + std::to_string(i), false)}); } memgraph::query::plan::Aggregate aggregate(scan_all, aggregations, group_by, symbols); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -450,7 +452,7 @@ static void OrderBy(benchmark::State &state) { sort_items.push_back({memgraph::query::Ordering::ASC, ast.Create(rand_value)}); } memgraph::query::plan::OrderBy order_by(scan_all, sort_items, symbols); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -489,7 +491,7 @@ static void Unwind(benchmark::State &state) { auto *list_expr = ast.Create("list")->MapTo(list_sym); auto out_sym = symbol_table.CreateSymbol("out", false); memgraph::query::plan::Unwind unwind(scan_all, list_expr, out_sym); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // We need to only set the memory for temporary (per pull) evaluations TMemory per_pull_memory; @@ -527,7 +529,7 @@ static void Foreach(benchmark::State &state) { std::make_shared(nullptr, memgraph::query::plan::NodeCreationInfo{}); auto foreach = std::make_shared(nullptr, std::move(create_node), list_expr, out_sym); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); TMemory per_pull_memory; memgraph::query::EvaluationContext evaluation_context{per_pull_memory.get()}; diff --git a/tests/benchmark/query/planner.cpp b/tests/benchmark/query/planner.cpp index 8cc90fe05..52cb44490 100644 --- a/tests/benchmark/query/planner.cpp +++ b/tests/benchmark/query/planner.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +19,8 @@ #include "query/plan/vertex_count_cache.hpp" #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; + // Add chained MATCH (node1) -- (node2), MATCH (node2) -- (node3) ... clauses. static memgraph::query::CypherQuery *AddChainedMatches(int num_matches, memgraph::query::AstStorage &storage) { auto *query = storage.Create(); @@ -44,7 +46,7 @@ static memgraph::query::CypherQuery *AddChainedMatches(int num_matches, memgraph static void BM_PlanChainedMatches(benchmark::State &state) { std::unique_ptr db(new memgraph::storage::InMemoryStorage()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); while (state.KeepRunning()) { state.PauseTiming(); @@ -95,10 +97,10 @@ static auto CreateIndexedVertices(int index_count, int vertex_count, memgraph::s auto label = db->NameToLabel("label"); auto prop = db->NameToProperty("prop"); { - auto unique_acc = db->UniqueAccess(); + auto unique_acc = db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); } - auto dba = db->Access(); + auto dba = db->Access(ReplicationRole::MAIN); for (int vi = 0; vi < vertex_count; ++vi) { for (int index = 0; index < index_count; ++index) { auto vertex = dba->CreateVertex(); @@ -117,7 +119,7 @@ static void BM_PlanAndEstimateIndexedMatching(benchmark::State &state) { int index_count = state.range(0); int vertex_count = state.range(1); std::tie(label, prop) = CreateIndexedVertices(index_count, vertex_count, db.get()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); memgraph::query::Parameters parameters; while (state.KeepRunning()) { @@ -146,7 +148,7 @@ static void BM_PlanAndEstimateIndexedMatchingWithCachedCounts(benchmark::State & int index_count = state.range(0); int vertex_count = state.range(1); std::tie(label, prop) = CreateIndexedVertices(index_count, vertex_count, db.get()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto vertex_counts = memgraph::query::plan::MakeVertexCountCache(&dba); memgraph::query::Parameters parameters; diff --git a/tests/benchmark/query/profile.cpp b/tests/benchmark/query/profile.cpp index 1c28fd21c..49b97fc83 100644 --- a/tests/benchmark/query/profile.cpp +++ b/tests/benchmark/query/profile.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -141,9 +141,9 @@ struct ScopedProfile { } } - Context *context; - ProfilingStats *stats; - unsigned long long start_time; + Context *context = nullptr; + ProfilingStats *stats = nullptr; + unsigned long long start_time{}; }; ////////////////////////////////////////////////////////////////////////////// diff --git a/tests/benchmark/storage_v2_gc.cpp b/tests/benchmark/storage_v2_gc.cpp index 3941fcbe1..246df09f6 100644 --- a/tests/benchmark/storage_v2_gc.cpp +++ b/tests/benchmark/storage_v2_gc.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +17,8 @@ #include "storage/v2/storage.hpp" #include "utils/timer.hpp" +using memgraph::replication::ReplicationRole; + // This benchmark should be run for a fixed amount of time that is // large compared to GC interval to make the output relevant. @@ -42,7 +44,7 @@ void UpdateLabelFunc(int thread_id, memgraph::storage::Storage *storage, memgraph::utils::Timer timer; for (int iter = 0; iter < num_iterations; ++iter) { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); memgraph::storage::Gid gid = vertices.at(vertex_dist(gen)); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); MG_ASSERT(vertex.has_value(), "Vertex with GID {} doesn't exist", gid.AsUint()); @@ -61,7 +63,7 @@ int main(int argc, char *argv[]) { std::unique_ptr storage(new memgraph::storage::InMemoryStorage(config.second)); std::vector vertices; { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); for (int i = 0; i < FLAGS_num_vertices; ++i) { vertices.push_back(acc->CreateVertex().Gid()); } diff --git a/tests/benchmark/storage_v2_gc2.cpp b/tests/benchmark/storage_v2_gc2.cpp index a8c0a589e..52aa01870 100644 --- a/tests/benchmark/storage_v2_gc2.cpp +++ b/tests/benchmark/storage_v2_gc2.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +17,8 @@ #include "storage/v2/storage.hpp" #include "utils/timer.hpp" +using memgraph::replication::ReplicationRole; + // This benchmark should be run for a fixed amount of time that is // large compared to GC interval to make the output relevant. @@ -41,14 +43,14 @@ int main(int argc, char *argv[]) { std::array vertices; memgraph::storage::PropertyId pid; { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); vertices[0] = acc->CreateVertex().Gid(); pid = acc->NameToProperty("NEW_PROP"); MG_ASSERT(!acc->Commit().HasError()); } for (int iter = 0; iter != FLAGS_num_iterations; ++iter) { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(vertices[0], memgraph::storage::View::OLD); for (auto i = 0; i != FLAGS_num_poperties; ++i) { MG_ASSERT(!vertex1.value().SetProperty(pid, memgraph::storage::PropertyValue{i}).HasError()); diff --git a/tests/concurrent/storage_indices.cpp b/tests/concurrent/storage_indices.cpp index a3c09d2e4..967e98c91 100644 --- a/tests/concurrent/storage_indices.cpp +++ b/tests/concurrent/storage_indices.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +19,8 @@ #include "storage/v2/storage_error.hpp" #include "utils/thread.hpp" +using memgraph::replication::ReplicationRole; + const uint64_t kNumVerifiers = 5; const uint64_t kNumMutators = 1; @@ -31,7 +33,7 @@ TEST(Storage, LabelIndex) { auto label = store->NameToLabel("label"); { - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label).HasError()); } @@ -44,7 +46,7 @@ TEST(Storage, LabelIndex) { gids.reserve(kNumIterations * kVerifierBatchSize); for (uint64_t i = 0; i < kNumIterations; ++i) { for (uint64_t j = 0; j < kVerifierBatchSize; ++j) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gids.emplace(vertex.Gid(), false); auto ret = vertex.AddLabel(label); @@ -53,7 +55,7 @@ TEST(Storage, LabelIndex) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertices = acc->Vertices(label, memgraph::storage::View::OLD); for (auto vertex : vertices) { auto it = gids.find(vertex.Gid()); @@ -81,7 +83,7 @@ TEST(Storage, LabelIndex) { gids.resize(kMutatorBatchSize); while (mutators_run.load(std::memory_order_acquire)) { for (uint64_t i = 0; i < kMutatorBatchSize; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gids[i] = vertex.Gid(); auto ret = vertex.AddLabel(label); @@ -90,7 +92,7 @@ TEST(Storage, LabelIndex) { ASSERT_FALSE(acc->Commit().HasError()); } for (uint64_t i = 0; i < kMutatorBatchSize; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE(acc->DeleteVertex(&*vertex).HasValue()); @@ -116,7 +118,7 @@ TEST(Storage, LabelPropertyIndex) { auto label = store->NameToLabel("label"); auto prop = store->NameToProperty("prop"); { - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label, prop).HasError()); } @@ -129,7 +131,7 @@ TEST(Storage, LabelPropertyIndex) { gids.reserve(kNumIterations * kVerifierBatchSize); for (uint64_t i = 0; i < kNumIterations; ++i) { for (uint64_t j = 0; j < kVerifierBatchSize; ++j) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gids.emplace(vertex.Gid(), false); { @@ -145,7 +147,7 @@ TEST(Storage, LabelPropertyIndex) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertices = acc->Vertices(label, prop, memgraph::storage::View::OLD); for (auto vertex : vertices) { auto it = gids.find(vertex.Gid()); @@ -173,7 +175,7 @@ TEST(Storage, LabelPropertyIndex) { gids.resize(kMutatorBatchSize); while (mutators_run.load(std::memory_order_acquire)) { for (uint64_t i = 0; i < kMutatorBatchSize; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gids[i] = vertex.Gid(); { @@ -189,7 +191,7 @@ TEST(Storage, LabelPropertyIndex) { ASSERT_FALSE(acc->Commit().HasError()); } for (uint64_t i = 0; i < kMutatorBatchSize; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE(acc->DeleteVertex(&*vertex).HasValue()); diff --git a/tests/concurrent/storage_unique_constraints.cpp b/tests/concurrent/storage_unique_constraints.cpp index 694249779..7defb4211 100644 --- a/tests/concurrent/storage_unique_constraints.cpp +++ b/tests/concurrent/storage_unique_constraints.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,8 @@ #include "storage/v2/constraints/constraints.hpp" #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; + const int kNumThreads = 8; #define ASSERT_OK(x) ASSERT_FALSE((x).HasError()) @@ -34,7 +36,7 @@ class StorageUniqueConstraints : public ::testing::Test { void SetUp() override { // Create initial vertices. - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->CreateVertex(); @@ -55,7 +57,7 @@ void SetProperties(memgraph::storage::Storage *storage, memgraph::storage::Gid g const std::vector &properties, const std::vector &values, bool *commit_status) { ASSERT_EQ(properties.size(), values.size()); - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); int value = 0; @@ -71,7 +73,7 @@ void SetProperties(memgraph::storage::Storage *storage, memgraph::storage::Gid g } void AddLabel(memgraph::storage::Storage *storage, memgraph::storage::Gid gid, LabelId label, bool *commit_status) { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); for (int iter = 0; iter < 40000; ++iter) { @@ -84,7 +86,7 @@ void AddLabel(memgraph::storage::Storage *storage, memgraph::storage::Gid gid, L TEST_F(StorageUniqueConstraints, ChangeProperties) { { - auto unique_acc = storage->UniqueAccess(); + auto unique_acc = storage->UniqueAccess(ReplicationRole::MAIN); auto res = unique_acc->CreateUniqueConstraint(label, {prop1, prop2, prop3}); ASSERT_TRUE(res.HasValue()); ASSERT_EQ(res.GetValue(), memgraph::storage::UniqueConstraints::CreationStatus::SUCCESS); @@ -92,7 +94,7 @@ TEST_F(StorageUniqueConstraints, ChangeProperties) { } { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); @@ -168,7 +170,7 @@ TEST_F(StorageUniqueConstraints, ChangeProperties) { TEST_F(StorageUniqueConstraints, ChangeLabels) { { - auto unique_acc = storage->UniqueAccess(); + auto unique_acc = storage->UniqueAccess(ReplicationRole::MAIN); auto res = unique_acc->CreateUniqueConstraint(label, {prop1, prop2, prop3}); ASSERT_TRUE(res.HasValue()); ASSERT_EQ(res.GetValue(), memgraph::storage::UniqueConstraints::CreationStatus::SUCCESS); @@ -181,7 +183,7 @@ TEST_F(StorageUniqueConstraints, ChangeLabels) { // succeed, as the others should result with constraint violation. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); @@ -196,7 +198,7 @@ TEST_F(StorageUniqueConstraints, ChangeLabels) { for (int iter = 0; iter < 20; ++iter) { // Clear labels. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); @@ -227,7 +229,7 @@ TEST_F(StorageUniqueConstraints, ChangeLabels) { // should succeed. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); @@ -242,7 +244,7 @@ TEST_F(StorageUniqueConstraints, ChangeLabels) { for (int iter = 0; iter < 20; ++iter) { // Clear labels. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // NOLINTNEXTLINE(modernize-loop-convert) for (int i = 0; i < kNumThreads; ++i) { auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); diff --git a/tests/e2e/replication/show_while_creating_invalid_state.py b/tests/e2e/replication/show_while_creating_invalid_state.py index 74dcbce74..a94310f0a 100644 --- a/tests/e2e/replication/show_while_creating_invalid_state.py +++ b/tests/e2e/replication/show_while_creating_invalid_state.py @@ -1754,5 +1754,74 @@ def test_triggers_on_create_before_commit_with_offline_sync_replica(): assert res_from_main == interactive_mg_runner.MEMGRAPH_INSTANCES["sync_replica2"].query(QUERY_TO_CHECK) +def test_replication_not_messed_up_by_CreateSnapshot(connection): + # Goal of this test is to check the replica can not run CreateSnapshot + # 1/ CREATE SNAPSHOT should raise a DatabaseError + + interactive_mg_runner.start_all(MEMGRAPH_INSTANCES_DESCRIPTION) + + cursor = connection(7688, "replica_1").cursor() + + # 1/ + with pytest.raises(mgclient.DatabaseError): + execute_and_fetch_all(cursor, "CREATE SNAPSHOT;") + + +def test_replication_not_messed_up_by_ShowIndexInfo(connection): + # Goal of this test is to check the replicas timestamp and hence ability to recieve MAINs writes + # is uneffected by SHOW INDEX INFO + + # 1/ Run SHOW INDEX INFO; multiple times on REPLICA + # 2/ Send a write from MAIN + # 3/ Check REPLICA processed the write + + BASIC_MEMGRAPH_INSTANCES_DESCRIPTION = { + "replica_1": { + "args": ["--bolt-port", "7688", "--log-level=TRACE"], + "log_file": "replica1.log", + "setup_queries": ["SET REPLICATION ROLE TO REPLICA WITH PORT 10001;"], + }, + "main": { + "args": ["--bolt-port", "7687", "--log-level=TRACE"], + "log_file": "main.log", + "setup_queries": [ + "REGISTER REPLICA replica_1 ASYNC TO '127.0.0.1:10001';", + ], + }, + } + + interactive_mg_runner.start_all(BASIC_MEMGRAPH_INSTANCES_DESCRIPTION) + + cursor = connection(7688, "replica_1").cursor() + + # 1/ + # This query use to incorrectly change REPLICA storage timestamp + # run this multiple times to try and get into error case of MAIN timestamp < REPLICA timestamp + for _ in range(20): + execute_and_fetch_all(cursor, "SHOW INDEX INFO;") + + cursor = connection(7687, "main").cursor() + + # 2/ + execute_and_fetch_all(cursor, "CREATE ();") + + def retrieve_data(): + replicas = interactive_mg_runner.MEMGRAPH_INSTANCES["main"].query("SHOW REPLICAS;") + return replicas + + expected_data = [ + ("replica_1", "127.0.0.1:10001", "async", 2, 0, "ready"), + ] + actual_data = mg_sleep_and_assert(expected_data, retrieve_data) + assert actual_data == expected_data + + # 3/ + cursor = connection(7688, "replica_1").cursor() + result = execute_and_fetch_all(cursor, "MATCH () RETURN count(*);") + + assert len(result) == 1 + assert result[0][0] == 1 # The one node was replicated from MAIN to REPLICA + + if __name__ == "__main__": sys.exit(pytest.main([__file__, "-rA"])) diff --git a/tests/manual/query_planner.cpp b/tests/manual/query_planner.cpp index 700b70a7a..f455bf716 100644 --- a/tests/manual/query_planner.cpp +++ b/tests/manual/query_planner.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,14 +14,14 @@ #include #include "storage/v2/inmemory/storage.hpp" - +using memgraph::replication::ReplicationRole; DECLARE_int32(min_log_level); int main(int argc, char *argv[]) { gflags::ParseCommandLineFlags(&argc, &argv, true); spdlog::set_level(spdlog::level::err); std::unique_ptr db(new memgraph::storage::InMemoryStorage()); - auto storage_dba = db->Access(); + auto storage_dba = db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); RunInteractivePlanning(&dba); return 0; diff --git a/tests/property_based/random_graph.cpp b/tests/property_based/random_graph.cpp index 1f12df2a1..ae71a68c8 100644 --- a/tests/property_based/random_graph.cpp +++ b/tests/property_based/random_graph.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -23,7 +23,7 @@ #include "storage/v2/inmemory/storage.hpp" #include "storage/v2/storage.hpp" #include "storage/v2/vertex_accessor.hpp" - +using memgraph::replication::ReplicationRole; /** * It is possible to run test with custom seed with: * RC_PARAMS="seed=1" ./random_graph @@ -40,7 +40,7 @@ RC_GTEST_PROP(RandomGraph, RandomGraph, (std::vector vertex_labels, std::unordered_map vertex_label_map; std::unordered_map edge_type_map; - auto dba = db->Access(); + auto dba = db->Access(ReplicationRole::MAIN); for (auto label : vertex_labels) { auto vertex_accessor = dba->CreateVertex(); diff --git a/tests/unit/auth_checker.cpp b/tests/unit/auth_checker.cpp index b048e9491..0122a4440 100644 --- a/tests/unit/auth_checker.cpp +++ b/tests/unit/auth_checker.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,7 @@ #include "storage/v2/disk/storage.hpp" #include "storage/v2/inmemory/storage.hpp" #include "storage/v2/view.hpp" - +using memgraph::replication::ReplicationRole; #ifdef MG_ENTERPRISE template class FineGrainedAuthCheckerFixture : public testing::Test { @@ -31,7 +31,7 @@ class FineGrainedAuthCheckerFixture : public testing::Test { memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; // make a V-graph (v3)<-[r2]-(v1)-[r1]->(v2) diff --git a/tests/unit/bfs_fine_grained.cpp b/tests/unit/bfs_fine_grained.cpp index 235431804..1557910fe 100644 --- a/tests/unit/bfs_fine_grained.cpp +++ b/tests/unit/bfs_fine_grained.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -42,7 +42,9 @@ class VertexDb : public Database { } } - std::unique_ptr Access() override { return db_->Access(); } + std::unique_ptr Access() override { + return db_->Access(memgraph::replication::ReplicationRole::MAIN); + } std::unique_ptr MakeBfsOperator(Symbol source_sym, Symbol sink_sym, Symbol edge_sym, EdgeAtom::Direction direction, diff --git a/tests/unit/bfs_single_node.cpp b/tests/unit/bfs_single_node.cpp index 37aae0491..a518a7729 100644 --- a/tests/unit/bfs_single_node.cpp +++ b/tests/unit/bfs_single_node.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -31,7 +31,9 @@ class SingleNodeDb : public Database { } } - std::unique_ptr Access() override { return db_->Access(); } + std::unique_ptr Access() override { + return db_->Access(memgraph::replication::ReplicationRole::MAIN); + } std::unique_ptr MakeBfsOperator(Symbol source_sym, Symbol sink_sym, Symbol edge_sym, EdgeAtom::Direction direction, diff --git a/tests/unit/bolt_encoder.cpp b/tests/unit/bolt_encoder.cpp index 6ffb4b496..83add3cd3 100644 --- a/tests/unit/bolt_encoder.cpp +++ b/tests/unit/bolt_encoder.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -182,7 +182,7 @@ void TestVertexAndEdgeWithDifferentStorages(std::unique_ptrAccess(); + auto dba = db->Access(memgraph::replication::ReplicationRole::MAIN); auto va1 = dba->CreateVertex(); auto va2 = dba->CreateVertex(); auto l1 = dba->NameToLabel("label1"); diff --git a/tests/unit/clearing_old_disk_data.cpp b/tests/unit/clearing_old_disk_data.cpp index 92b0de134..76315115a 100644 --- a/tests/unit/clearing_old_disk_data.cpp +++ b/tests/unit/clearing_old_disk_data.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -20,6 +20,8 @@ #include "storage/v2/property_value.hpp" #include "storage/v2/view.hpp" +using memgraph::replication::ReplicationRole; + class ClearingOldDiskDataTest : public ::testing::Test { public: const std::string testSuite = "clearing_old_disk_data"; @@ -33,7 +35,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexTimestampUpdate) { auto *tx_db = disk_storage->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 0); - auto acc1 = disk_storage->Access(std::nullopt); + auto acc1 = disk_storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto label1 = acc1->NameToLabel("DiskLabel"); auto property1 = acc1->NameToProperty("DiskProperty"); @@ -43,7 +45,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexTimestampUpdate) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = disk_storage->Access(std::nullopt); + auto acc2 = disk_storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW).value(); /// This is the same property as in the first transaction, we just want to test /// the number of entries inside RocksDB when the timestamp changes @@ -58,7 +60,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexValueUpdate) { auto *tx_db = disk_storage->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 0); - auto acc1 = disk_storage->Access(std::nullopt); + auto acc1 = disk_storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto label1 = acc1->NameToLabel("DiskLabel"); auto property1 = acc1->NameToProperty("DiskProperty"); @@ -68,7 +70,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexValueUpdate) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = disk_storage->Access(std::nullopt); + auto acc2 = disk_storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW).value(); /// This is the same property as in the first transaction, we just want to test /// the number of entries inside RocksDB when the timestamp changes @@ -83,7 +85,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexKeyUpdate) { auto *tx_db = disk_storage->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 0); - auto acc1 = disk_storage->Access(std::nullopt); + auto acc1 = disk_storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto label1 = acc1->NameToLabel("DiskLabel"); auto property1 = acc1->NameToProperty("DiskProperty"); @@ -93,7 +95,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithVertexKeyUpdate) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = disk_storage->Access(std::nullopt); + auto acc2 = disk_storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW).value(); auto label2 = acc2->NameToLabel("DiskLabel2"); ASSERT_TRUE(vertex2.AddLabel(label2).HasValue()); @@ -106,7 +108,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithEdgeTimestampUpdate) { auto *tx_db = disk_storage->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 0); - auto acc1 = disk_storage->Access(std::nullopt); + auto acc1 = disk_storage->Access(ReplicationRole::MAIN); auto label1 = acc1->NameToLabel("DiskLabel"); auto property1 = acc1->NameToProperty("DiskProperty"); @@ -126,7 +128,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithEdgeTimestampUpdate) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 5); - auto acc2 = disk_storage->Access(std::nullopt); + auto acc2 = disk_storage->Access(ReplicationRole::MAIN); auto from_vertex = acc2->FindVertex(from.Gid(), memgraph::storage::View::NEW).value(); auto ret = from_vertex.OutEdges(memgraph::storage::View::NEW); @@ -145,7 +147,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithEdgeValueUpdate) { auto *tx_db = disk_storage->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 0); - auto acc1 = disk_storage->Access(std::nullopt); + auto acc1 = disk_storage->Access(ReplicationRole::MAIN); auto label1 = acc1->NameToLabel("DiskLabel"); auto property1 = acc1->NameToProperty("DiskProperty"); @@ -165,7 +167,7 @@ TEST_F(ClearingOldDiskDataTest, TestNumOfEntriesWithEdgeValueUpdate) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 5); - auto acc2 = disk_storage->Access(std::nullopt); + auto acc2 = disk_storage->Access(ReplicationRole::MAIN); auto from_vertex = acc2->FindVertex(from.Gid(), memgraph::storage::View::NEW).value(); auto ret = from_vertex.OutEdges(memgraph::storage::View::NEW); diff --git a/tests/unit/cpp_api.cpp b/tests/unit/cpp_api.cpp index 012b2d713..ce968b13e 100644 --- a/tests/unit/cpp_api.cpp +++ b/tests/unit/cpp_api.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -43,7 +43,7 @@ struct CppApiTestFixture : public ::testing::Test { } memgraph::query::DbAccessor &CreateDbAccessor(const memgraph::storage::IsolationLevel isolationLevel) { - accessors_.push_back(storage->Access(isolationLevel)); + accessors_.push_back(storage->Access(memgraph::replication::ReplicationRole::MAIN, isolationLevel)); db_accessors_.emplace_back(accessors_.back().get()); return db_accessors_.back(); } diff --git a/tests/unit/database_get_info.cpp b/tests/unit/database_get_info.cpp index aac38159d..95ed3f326 100644 --- a/tests/unit/database_get_info.cpp +++ b/tests/unit/database_get_info.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -93,12 +93,12 @@ TYPED_TEST(InfoTest, InfoCheck) { { { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateExistenceConstraint(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->DropExistenceConstraint(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } @@ -123,49 +123,50 @@ TYPED_TEST(InfoTest, InfoCheck) { } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateIndex(lbl).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateIndex(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateIndex(lbl, prop2).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->DropIndex(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl, {prop2}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl2, {prop}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl3, {prop}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db_acc->storage()->UniqueAccess(); + auto unique_acc = db_acc->UniqueAccess(); ASSERT_EQ(unique_acc->DropUniqueConstraint(lbl, {prop2}), memgraph::storage::UniqueConstraints::DeletionStatus::SUCCESS); ASSERT_FALSE(unique_acc->Commit().HasError()); } - const auto &info = db_acc->GetInfo(true); // force to use configured directory + const auto &info = + db_acc->GetInfo(true, memgraph::replication::ReplicationRole::MAIN); // force to use configured directory ASSERT_EQ(info.storage_info.vertex_count, 5); ASSERT_EQ(info.storage_info.edge_count, 2); diff --git a/tests/unit/plan_pretty_print.cpp b/tests/unit/plan_pretty_print.cpp index 97f1355cb..4a513e82c 100644 --- a/tests/unit/plan_pretty_print.cpp +++ b/tests/unit/plan_pretty_print.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -43,7 +43,7 @@ class PrintToJsonTest : public ::testing::Test { PrintToJsonTest() : config(disk_test_utils::GenerateOnDiskConfig(testSuite)), db(new StorageType(config)), - dba_storage(db->Access()), + dba_storage(db->Access(memgraph::replication::ReplicationRole::MAIN)), dba(dba_storage.get()) {} ~PrintToJsonTest() override { diff --git a/tests/unit/query_cost_estimator.cpp b/tests/unit/query_cost_estimator.cpp index f3d6b3864..ff9525cdc 100644 --- a/tests/unit/query_cost_estimator.cpp +++ b/tests/unit/query_cost_estimator.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,7 @@ using namespace memgraph::query; using namespace memgraph::query::plan; - +using memgraph::replication::ReplicationRole; using CardParam = CostEstimator::CardParam; using CostParam = CostEstimator::CostParam; using MiscParam = CostEstimator::MiscParam; @@ -51,16 +51,16 @@ class QueryCostEstimator : public ::testing::Test { void SetUp() override { { - auto unique_acc = db->UniqueAccess(); + auto unique_acc = db->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = db->UniqueAccess(); + auto unique_acc = db->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label, property).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } - storage_dba.emplace(db->Access()); + storage_dba.emplace(db->Access(ReplicationRole::MAIN)); dba.emplace(storage_dba->get()); } diff --git a/tests/unit/query_dump.cpp b/tests/unit/query_dump.cpp index 63019ad28..1a4dd6264 100644 --- a/tests/unit/query_dump.cpp +++ b/tests/unit/query_dump.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -137,7 +137,7 @@ DatabaseState GetState(memgraph::storage::Storage *db) { // Capture all vertices std::map gid_mapping; std::set vertices; - auto dba = db->Access(); + auto dba = db->Access(memgraph::replication::ReplicationRole::MAIN); for (const auto &vertex : dba->Vertices(memgraph::storage::View::NEW)) { std::set> labels; auto maybe_labels = vertex.Labels(memgraph::storage::View::NEW); @@ -329,7 +329,7 @@ TYPED_TEST(DumpTest, EmptyGraph) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -339,7 +339,7 @@ TYPED_TEST(DumpTest, EmptyGraph) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, SingleVertex) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {}, {}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -348,7 +348,7 @@ TYPED_TEST(DumpTest, SingleVertex) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -360,7 +360,7 @@ TYPED_TEST(DumpTest, SingleVertex) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, VertexWithSingleLabel) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {"Label1"}, {}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -369,7 +369,7 @@ TYPED_TEST(DumpTest, VertexWithSingleLabel) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -381,7 +381,7 @@ TYPED_TEST(DumpTest, VertexWithSingleLabel) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, VertexWithMultipleLabels) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {"Label1", "Label 2"}, {}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -390,7 +390,7 @@ TYPED_TEST(DumpTest, VertexWithMultipleLabels) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -403,7 +403,7 @@ TYPED_TEST(DumpTest, VertexWithMultipleLabels) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, VertexWithSingleProperty) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {}, {{"prop", memgraph::storage::PropertyValue(42)}}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -412,7 +412,7 @@ TYPED_TEST(DumpTest, VertexWithSingleProperty) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -424,7 +424,7 @@ TYPED_TEST(DumpTest, VertexWithSingleProperty) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, MultipleVertices) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {}, {}, false); CreateVertex(dba.get(), {}, {}, false); CreateVertex(dba.get(), {}, {}, false); @@ -435,7 +435,7 @@ TYPED_TEST(DumpTest, MultipleVertices) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -447,7 +447,7 @@ TYPED_TEST(DumpTest, MultipleVertices) { TYPED_TEST(DumpTest, PropertyValue) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto null_value = memgraph::storage::PropertyValue(); auto int_value = memgraph::storage::PropertyValue(13); auto bool_value = memgraph::storage::PropertyValue(true); @@ -473,7 +473,7 @@ TYPED_TEST(DumpTest, PropertyValue) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -489,7 +489,7 @@ TYPED_TEST(DumpTest, PropertyValue) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, SingleEdge) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto u = CreateVertex(dba.get(), {}, {}, false); auto v = CreateVertex(dba.get(), {}, {}, false); CreateEdge(dba.get(), &u, &v, "EdgeType", {}, false); @@ -500,7 +500,7 @@ TYPED_TEST(DumpTest, SingleEdge) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -515,7 +515,7 @@ TYPED_TEST(DumpTest, SingleEdge) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, MultipleEdges) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto u = CreateVertex(dba.get(), {}, {}, false); auto v = CreateVertex(dba.get(), {}, {}, false); auto w = CreateVertex(dba.get(), {}, {}, false); @@ -529,7 +529,7 @@ TYPED_TEST(DumpTest, MultipleEdges) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -548,7 +548,7 @@ TYPED_TEST(DumpTest, MultipleEdges) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, EdgeWithProperties) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto u = CreateVertex(dba.get(), {}, {}, false); auto v = CreateVertex(dba.get(), {}, {}, false); CreateEdge(dba.get(), &u, &v, "EdgeType", {{"prop", memgraph::storage::PropertyValue(13)}}, false); @@ -559,7 +559,7 @@ TYPED_TEST(DumpTest, EdgeWithProperties) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -574,7 +574,7 @@ TYPED_TEST(DumpTest, EdgeWithProperties) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, IndicesKeys) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {"Label1", "Label 2"}, {{"p", memgraph::storage::PropertyValue(1)}}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -599,7 +599,7 @@ TYPED_TEST(DumpTest, IndicesKeys) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -612,7 +612,7 @@ TYPED_TEST(DumpTest, IndicesKeys) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, ExistenceConstraints) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {"L`abel 1"}, {{"prop", memgraph::storage::PropertyValue(1)}}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -628,7 +628,7 @@ TYPED_TEST(DumpTest, ExistenceConstraints) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -640,7 +640,7 @@ TYPED_TEST(DumpTest, ExistenceConstraints) { TYPED_TEST(DumpTest, UniqueConstraints) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {"Label"}, {{"prop", memgraph::storage::PropertyValue(1)}, {"prop2", memgraph::storage::PropertyValue(2)}}, false); @@ -663,7 +663,7 @@ TYPED_TEST(DumpTest, UniqueConstraints) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -682,7 +682,7 @@ TYPED_TEST(DumpTest, UniqueConstraints) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, CheckStateVertexWithMultipleProperties) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); std::map prop1 = { {"nested1", memgraph::storage::PropertyValue(1337)}, {"nested2", memgraph::storage::PropertyValue(3.14)}}; @@ -722,7 +722,7 @@ TYPED_TEST(DumpTest, CheckStateVertexWithMultipleProperties) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -739,7 +739,7 @@ TYPED_TEST(DumpTest, CheckStateVertexWithMultipleProperties) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, CheckStateSimpleGraph) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto u = CreateVertex(dba.get(), {"Person"}, {{"name", memgraph::storage::PropertyValue("Ivan")}}); auto v = CreateVertex(dba.get(), {"Person"}, {{"name", memgraph::storage::PropertyValue("Josko")}}); auto w = CreateVertex( @@ -839,7 +839,7 @@ TYPED_TEST(DumpTest, CheckStateSimpleGraph) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); { - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::DumpDatabaseToCypherQueries(&dba, &query_stream); } @@ -862,7 +862,7 @@ TYPED_TEST(DumpTest, CheckStateSimpleGraph) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(DumpTest, ExecuteDumpDatabase) { { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {}, {}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -925,7 +925,7 @@ TYPED_TEST(DumpTest, ExecuteDumpDatabaseInMulticommandTransaction) { // Create the vertex. { - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); CreateVertex(dba.get(), {}, {}, false); ASSERT_FALSE(dba->Commit().HasError()); } @@ -1023,7 +1023,7 @@ TYPED_TEST(DumpTest, MultiplePartialPulls) { ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto dba = this->db->storage()->Access(); + auto dba = this->db->Access(); auto p1 = CreateVertex(dba.get(), {"PERSON"}, {{"name", memgraph::storage::PropertyValue("Person1")}, {"surname", memgraph::storage::PropertyValue("Unique1")}}, @@ -1053,7 +1053,7 @@ TYPED_TEST(DumpTest, MultiplePartialPulls) { ResultStreamFaker stream(this->db->storage()); memgraph::query::AnyStream query_stream(&stream, memgraph::utils::NewDeleteResource()); - auto acc = this->db->storage()->Access(); + auto acc = this->db->Access(); memgraph::query::DbAccessor dba(acc.get()); memgraph::query::PullPlanDump pullPlan{&dba}; diff --git a/tests/unit/query_expression_evaluator.cpp b/tests/unit/query_expression_evaluator.cpp index c9786fe5e..c070aaa32 100644 --- a/tests/unit/query_expression_evaluator.cpp +++ b/tests/unit/query_expression_evaluator.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -67,7 +67,7 @@ class ExpressionEvaluatorTest : public ::testing::Test { ExpressionEvaluatorTest() : config(disk_test_utils::GenerateOnDiskConfig(testSuite)), db(new StorageType(config)), - storage_dba(db->Access()), + storage_dba(db->Access(memgraph::replication::ReplicationRole::MAIN)), dba(storage_dba.get()) {} ~ExpressionEvaluatorTest() override { diff --git a/tests/unit/query_hint_provider.cpp b/tests/unit/query_hint_provider.cpp index 9973bf2ca..5510812f1 100644 --- a/tests/unit/query_hint_provider.cpp +++ b/tests/unit/query_hint_provider.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -39,7 +39,7 @@ class HintProviderSuite : public ::testing::Test { int symbol_count = 0; void SetUp() { - storage_dba.emplace(db->Access()); + storage_dba.emplace(db->Access(memgraph::replication::ReplicationRole::MAIN)); dba.emplace(storage_dba->get()); } diff --git a/tests/unit/query_plan_accumulate_aggregate.cpp b/tests/unit/query_plan_accumulate_aggregate.cpp index b1e9a62d0..68498cc40 100644 --- a/tests/unit/query_plan_accumulate_aggregate.cpp +++ b/tests/unit/query_plan_accumulate_aggregate.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +25,8 @@ #include "storage/v2/disk/storage.hpp" #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; + using namespace memgraph::query; using namespace memgraph::query::plan; using memgraph::query::test_common::ToIntList; @@ -95,7 +97,7 @@ TYPED_TEST(QueryPlanTest, Accumulate) { this->db.reset(nullptr); this->CleanStorageDirs(); this->db = std::make_unique(this->config); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto prop = dba.NameToProperty("x"); @@ -148,7 +150,7 @@ TYPED_TEST(QueryPlanTest, AccumulateAdvance) { this->db.reset(); this->CleanStorageDirs(); this->db = std::make_unique(this->config); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; NodeCreationInfo node; @@ -167,7 +169,7 @@ TYPED_TEST(QueryPlanTest, AccumulateAdvance) { template class QueryPlanAggregateOps : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; memgraph::storage::PropertyId prop = this->db->NameToProperty("prop"); @@ -308,7 +310,7 @@ TYPED_TEST(QueryPlanTest, AggregateGroupByValues) { // Tests that distinct groups are aggregated properly for values of all types. // Also test the "remember" part of the Aggregation API as final results are // obtained via a property lookup of a remembered node. - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // a vector of memgraph::storage::PropertyValue to be set as property values on vertices @@ -370,7 +372,7 @@ TYPED_TEST(QueryPlanTest, AggregateMultipleGroupBy) { // in this test we have 3 different properties that have different values // for different records and assert that we get the correct combination // of values in our groups - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto prop1 = dba.NameToProperty("prop1"); @@ -401,7 +403,7 @@ TYPED_TEST(QueryPlanTest, AggregateMultipleGroupBy) { } TYPED_TEST(QueryPlanTest, AggregateNoInput) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -424,7 +426,7 @@ TYPED_TEST(QueryPlanTest, AggregateCountEdgeCases) { // - 2 vertices in database, property set on one // - 2 vertices in database, property set on both - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto prop = dba.NameToProperty("prop"); @@ -476,7 +478,7 @@ TYPED_TEST(QueryPlanTest, AggregateFirstValueTypes) { // testing exceptions that get emitted by the first-value // type check - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -528,7 +530,7 @@ TYPED_TEST(QueryPlanTest, AggregateTypes) { // does not check all combinations that can result in an exception // (that logic is defined and tested by TypedValue) - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto p1 = dba.NameToProperty("p1"); // has only string props @@ -581,7 +583,7 @@ TYPED_TEST(QueryPlanTest, AggregateTypes) { } TYPED_TEST(QueryPlanTest, Unwind) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -717,7 +719,7 @@ TYPED_TEST(QueryPlanTest, AggregateGroupByValuesWithDistinct) { // Tests that distinct groups are aggregated properly for values of all types. // Also test the "remember" part of the Aggregation API as final results are // obtained via a property lookup of a remembered node. - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // a vector of memgraph::storage::PropertyValue to be set as property values on vertices @@ -782,7 +784,7 @@ TYPED_TEST(QueryPlanTest, AggregateMultipleGroupByWithDistinct) { // in this test we have 3 different properties that have different values // for different records and assert that we get the correct combination // of values in our groups - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto prop1 = dba.NameToProperty("prop1"); @@ -814,7 +816,7 @@ TYPED_TEST(QueryPlanTest, AggregateMultipleGroupByWithDistinct) { } TYPED_TEST(QueryPlanTest, AggregateNoInputWithDistinct) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -837,7 +839,7 @@ TYPED_TEST(QueryPlanTest, AggregateCountEdgeCasesWithDistinct) { // - 2 vertices in database, property set on one // - 2 vertices in database, property set on both - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto prop = dba.NameToProperty("prop"); @@ -889,7 +891,7 @@ TYPED_TEST(QueryPlanTest, AggregateFirstValueTypesWithDistinct) { // testing exceptions that get emitted by the first-value // type check - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -941,7 +943,7 @@ TYPED_TEST(QueryPlanTest, AggregateTypesWithDistinct) { // does not check all combinations that can result in an exception // (that logic is defined and tested by TypedValue) - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto p1 = dba.NameToProperty("p1"); // has only string props diff --git a/tests/unit/query_plan_bag_semantics.cpp b/tests/unit/query_plan_bag_semantics.cpp index 6b1c7ab64..1bdaf68c1 100644 --- a/tests/unit/query_plan_bag_semantics.cpp +++ b/tests/unit/query_plan_bag_semantics.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -31,6 +31,7 @@ #include "query_plan_common.hpp" +using memgraph::replication::ReplicationRole; using namespace memgraph::query; using namespace memgraph::query::plan; @@ -53,7 +54,7 @@ using StorageTypes = ::testing::Typesdb->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -81,7 +82,7 @@ TYPED_TEST(QueryPlanTest, Skip) { } TYPED_TEST(QueryPlanTest, Limit) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -112,7 +113,7 @@ TYPED_TEST(QueryPlanTest, CreateLimit) { // CREATE (n), (m) // MATCH (n) CREATE (m) LIMIT 1 // in the end we need to have 3 vertices in the db - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); dba.InsertVertex(); dba.InsertVertex(); @@ -133,7 +134,7 @@ TYPED_TEST(QueryPlanTest, CreateLimit) { } TYPED_TEST(QueryPlanTest, OrderBy) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto prop = dba.NameToProperty("prop"); @@ -204,7 +205,7 @@ TYPED_TEST(QueryPlanTest, OrderBy) { } TYPED_TEST(QueryPlanTest, OrderByMultiple) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -256,7 +257,7 @@ TYPED_TEST(QueryPlanTest, OrderByMultiple) { } TYPED_TEST(QueryPlanTest, OrderByExceptions) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto prop = dba.NameToProperty("prop"); diff --git a/tests/unit/query_plan_create_set_remove_delete.cpp b/tests/unit/query_plan_create_set_remove_delete.cpp index d0127c7c6..fcb98cbd9 100644 --- a/tests/unit/query_plan_create_set_remove_delete.cpp +++ b/tests/unit/query_plan_create_set_remove_delete.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -38,6 +38,7 @@ using namespace memgraph::query; using namespace memgraph::query::plan; +using memgraph::replication::ReplicationRole; template class QueryPlanTest : public testing::Test { @@ -58,7 +59,7 @@ using StorageTypes = ::testing::Typesdb->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); memgraph::storage::LabelId label = dba.NameToLabel("Person"); @@ -102,7 +103,7 @@ TYPED_TEST(QueryPlanTest, CreateNodeWithAttributes) { TYPED_TEST(QueryPlanTest, FineGrainedCreateNodeWithAttributes) { memgraph::license::global_license_checker.EnableTesting(); memgraph::query::SymbolTable symbol_table; - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); DbAccessor execution_dba(dba.get()); const auto label = dba->NameToLabel("label1"); const auto property = memgraph::storage::PropertyId::FromInt(1); @@ -142,7 +143,7 @@ TYPED_TEST(QueryPlanTest, FineGrainedCreateNodeWithAttributes) { TYPED_TEST(QueryPlanTest, CreateReturn) { // test CREATE (n:Person {age: 42}) RETURN n, n.age - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); memgraph::storage::LabelId label = dba.NameToLabel("Person"); @@ -182,7 +183,7 @@ TYPED_TEST(QueryPlanTest, FineGrainedCreateReturn) { memgraph::license::global_license_checker.EnableTesting(); // test CREATE (n:Person {age: 42}) RETURN n, n.age - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); const auto label = dba.NameToLabel("label"); @@ -237,7 +238,7 @@ TYPED_TEST(QueryPlanTest, FineGrainedCreateReturn) { #endif TYPED_TEST(QueryPlanTest, CreateExpand) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); memgraph::storage::LabelId label_node_1 = dba.NameToLabel("Node1"); @@ -315,7 +316,7 @@ TYPED_TEST(QueryPlanTest, CreateExpand) { template class CreateExpandWithAuthFixture : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; @@ -445,7 +446,7 @@ TYPED_TEST(CreateExpandWithAuthFixture, CreateExpandWithCycleWithEverythingGrant } TYPED_TEST(QueryPlanTest, MatchCreateNode) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add three nodes we'll match and expand-create from @@ -473,7 +474,7 @@ TYPED_TEST(QueryPlanTest, MatchCreateNode) { template class MatchCreateNodeWithAuthFixture : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; @@ -553,7 +554,7 @@ TYPED_TEST(MatchCreateNodeWithAuthFixture, MatchCreateWithOneLabelDeniedThrows) #endif TYPED_TEST(QueryPlanTest, MatchCreateExpand) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add three nodes we'll match and expand-create from @@ -601,7 +602,7 @@ TYPED_TEST(QueryPlanTest, MatchCreateExpand) { template class MatchCreateExpandWithAuthFixture : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; @@ -746,7 +747,7 @@ TYPED_TEST(MatchCreateExpandWithAuthFixture, MatchCreateExpandWithCycleExecutesW #endif TYPED_TEST(QueryPlanTest, Delete) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // make a fully-connected (one-direction, no cycles) with 4 nodes @@ -818,7 +819,7 @@ TYPED_TEST(QueryPlanTest, Delete) { template class DeleteOperatorWithAuthFixture : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; @@ -978,7 +979,7 @@ TYPED_TEST(QueryPlanTest, DeleteTwiceDeleteBlockingEdge) { // MATCH (n)-[r]-(m) [DETACH] DELETE n, r, m auto test_delete = [this](bool detach) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -1013,7 +1014,7 @@ TYPED_TEST(QueryPlanTest, DeleteTwiceDeleteBlockingEdge) { TYPED_TEST(QueryPlanTest, DeleteReturn) { // MATCH (n) DETACH DELETE n RETURN n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // graph with 4 vertices @@ -1047,7 +1048,7 @@ TYPED_TEST(QueryPlanTest, DeleteReturn) { TYPED_TEST(QueryPlanTest, DeleteNull) { // test (simplified) WITH Null as x delete x - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -1071,7 +1072,7 @@ TYPED_TEST(QueryPlanTest, DeleteAdvance) { auto advance = std::make_shared(delete_op, std::vector{n.sym_}, true); auto res_sym = symbol_table.CreateSymbol("res", true); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); dba.InsertVertex(); dba.AdvanceCommand(); @@ -1080,7 +1081,7 @@ TYPED_TEST(QueryPlanTest, DeleteAdvance) { EXPECT_EQ(1, PullAll(*produce, &context)); } { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); dba.InsertVertex(); dba.AdvanceCommand(); @@ -1092,7 +1093,7 @@ TYPED_TEST(QueryPlanTest, DeleteAdvance) { } TYPED_TEST(QueryPlanTest, SetProperty) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // graph with 4 vertices in connected pairs @@ -1148,7 +1149,7 @@ TYPED_TEST(QueryPlanTest, SetProperty) { TYPED_TEST(QueryPlanTest, SetProperties) { auto test_set_properties = [this](bool update) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // graph: ({a: 0})-[:R {b:1}]->({c:2}) @@ -1221,7 +1222,7 @@ TYPED_TEST(QueryPlanTest, SetProperties) { } TYPED_TEST(QueryPlanTest, SetLabels) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); @@ -1271,7 +1272,7 @@ TYPED_TEST(QueryPlanTest, SetLabelsWithFineGrained) { memgraph::auth::User user{"test"}; user.fine_grained_access_handler().label_permissions().Grant("*", memgraph::auth::FineGrainedPermission::CREATE_DELETE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1288,7 +1289,7 @@ TYPED_TEST(QueryPlanTest, SetLabelsWithFineGrained) { { memgraph::auth::User user{"test"}; user.fine_grained_access_handler().label_permissions().Grant("*", memgraph::auth::FineGrainedPermission::UPDATE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1307,7 +1308,7 @@ TYPED_TEST(QueryPlanTest, SetLabelsWithFineGrained) { user.fine_grained_access_handler().label_permissions().Grant("label3", memgraph::auth::FineGrainedPermission::CREATE_DELETE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1319,7 +1320,7 @@ TYPED_TEST(QueryPlanTest, SetLabelsWithFineGrained) { #endif TYPED_TEST(QueryPlanTest, RemoveProperty) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // graph with 4 vertices in connected pairs @@ -1381,7 +1382,7 @@ TYPED_TEST(QueryPlanTest, RemoveProperty) { } TYPED_TEST(QueryPlanTest, RemoveLabels) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); @@ -1442,7 +1443,7 @@ TYPED_TEST(QueryPlanTest, RemoveLabelsFineGrainedFiltering) { memgraph::auth::User user{"test"}; user.fine_grained_access_handler().label_permissions().Grant("*", memgraph::auth::FineGrainedPermission::CREATE_DELETE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1459,7 +1460,7 @@ TYPED_TEST(QueryPlanTest, RemoveLabelsFineGrainedFiltering) { { memgraph::auth::User user{"test"}; user.fine_grained_access_handler().label_permissions().Grant("*", memgraph::auth::FineGrainedPermission::UPDATE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1478,7 +1479,7 @@ TYPED_TEST(QueryPlanTest, RemoveLabelsFineGrainedFiltering) { user.fine_grained_access_handler().label_permissions().Grant("label3", memgraph::auth::FineGrainedPermission::CREATE_DELETE); - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label1 = dba.NameToLabel("label1"); auto label2 = dba.NameToLabel("label2"); @@ -1490,7 +1491,7 @@ TYPED_TEST(QueryPlanTest, RemoveLabelsFineGrainedFiltering) { #endif TYPED_TEST(QueryPlanTest, NodeFilterSet) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Create a graph such that (v1 {prop: 42}) is connected to v2 and v3. auto v1 = dba.InsertVertex(); @@ -1528,7 +1529,7 @@ TYPED_TEST(QueryPlanTest, NodeFilterSet) { } TYPED_TEST(QueryPlanTest, FilterRemove) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Create a graph such that (v1 {prop: 42}) is connected to v2 and v3. auto v1 = dba.InsertVertex(); @@ -1562,7 +1563,7 @@ TYPED_TEST(QueryPlanTest, FilterRemove) { } TYPED_TEST(QueryPlanTest, SetRemove) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v = dba.InsertVertex(); auto label1 = dba.NameToLabel("label1"); @@ -1591,7 +1592,7 @@ TYPED_TEST(QueryPlanTest, Merge) { // - merge_match branch looks for an expansion (any direction) // and sets some property (for result validation) // - merge_create branch just sets some other property - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); auto v2 = dba.InsertVertex(); @@ -1633,7 +1634,7 @@ TYPED_TEST(QueryPlanTest, Merge) { TYPED_TEST(QueryPlanTest, MergeNoInput) { // merge with no input, creates a single node - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -1651,7 +1652,7 @@ TYPED_TEST(QueryPlanTest, MergeNoInput) { TYPED_TEST(QueryPlanTest, SetPropertyWithCaching) { // SET (Null).prop = 42 - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto prop = PROPERTY_PAIR(dba, "property"); @@ -1666,7 +1667,7 @@ TYPED_TEST(QueryPlanTest, SetPropertyWithCaching) { TYPED_TEST(QueryPlanTest, SetPropertyOnNull) { // SET (Null).prop = 42 - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto prop = PROPERTY_PAIR(dba, "property"); @@ -1681,7 +1682,7 @@ TYPED_TEST(QueryPlanTest, SetPropertyOnNull) { TYPED_TEST(QueryPlanTest, SetPropertiesOnNull) { // OPTIONAL MATCH (n) SET n = n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto n = MakeScanAll(this->storage, symbol_table, "n"); @@ -1694,7 +1695,7 @@ TYPED_TEST(QueryPlanTest, SetPropertiesOnNull) { } TYPED_TEST(QueryPlanTest, UpdateSetPropertiesFromMap) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. ( {property: 43}) auto vertex_accessor = dba.InsertVertex(); @@ -1729,7 +1730,7 @@ TYPED_TEST(QueryPlanTest, UpdateSetPropertiesFromMap) { } TYPED_TEST(QueryPlanTest, SetPropertiesFromMapWithCaching) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. ({prop1: 43, prop2: 44}) @@ -1769,7 +1770,7 @@ TYPED_TEST(QueryPlanTest, SetPropertiesFromMapWithCaching) { TYPED_TEST(QueryPlanTest, SetLabelsOnNull) { // OPTIONAL MATCH (n) SET n :label - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label = dba.NameToLabel("label"); SymbolTable symbol_table; @@ -1783,7 +1784,7 @@ TYPED_TEST(QueryPlanTest, SetLabelsOnNull) { TYPED_TEST(QueryPlanTest, RemovePropertyOnNull) { // REMOVE (Null).prop - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; auto prop = PROPERTY_PAIR(dba, "property"); @@ -1797,7 +1798,7 @@ TYPED_TEST(QueryPlanTest, RemovePropertyOnNull) { TYPED_TEST(QueryPlanTest, RemoveLabelsOnNull) { // OPTIONAL MATCH (n) REMOVE n :label - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto label = dba.NameToLabel("label"); SymbolTable symbol_table; @@ -1812,7 +1813,7 @@ TYPED_TEST(QueryPlanTest, RemoveLabelsOnNull) { TYPED_TEST(QueryPlanTest, DeleteSetProperty) { // MATCH (n) DELETE n SET n.property = 42 RETURN n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. dba.InsertVertex(); @@ -1838,7 +1839,7 @@ TYPED_TEST(QueryPlanTest, DeleteSetProperty) { TYPED_TEST(QueryPlanTest, DeleteSetPropertiesFromMap) { // MATCH (n) DELETE n SET n = {property: 42} return n // MATCH (n) DELETE n SET n += {property: 42} return n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. dba.InsertVertex(); @@ -1866,7 +1867,7 @@ TYPED_TEST(QueryPlanTest, DeleteSetPropertiesFromMap) { TYPED_TEST(QueryPlanTest, DeleteSetPropertiesFrom) { // MATCH (n) DELETE n SET n = n RETURN n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. { @@ -1895,7 +1896,7 @@ TYPED_TEST(QueryPlanTest, DeleteSetPropertiesFrom) { TYPED_TEST(QueryPlanTest, DeleteRemoveLabels) { // MATCH (n) DELETE n REMOVE n :label return n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. dba.InsertVertex(); @@ -1920,7 +1921,7 @@ TYPED_TEST(QueryPlanTest, DeleteRemoveLabels) { TYPED_TEST(QueryPlanTest, DeleteRemoveProperty) { // MATCH (n) DELETE n REMOVE n.property RETURN n - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a single vertex. dba.InsertVertex(); @@ -1950,7 +1951,7 @@ TYPED_TEST(QueryPlanTest, DeleteRemoveProperty) { template class UpdatePropertiesWithAuthFixture : public QueryPlanTest { protected: - std::unique_ptr storage_dba{this->db->Access()}; + std::unique_ptr storage_dba{this->db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; @@ -2587,7 +2588,7 @@ class DynamicExpandFixture : public testing::Test { const std::string testSuite = "query_plan_create_set_remove_delete_dynamic_expand"; memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; AstStorage storage; diff --git a/tests/unit/query_plan_match_filter_return.cpp b/tests/unit/query_plan_match_filter_return.cpp index 6b856704d..e97b10742 100644 --- a/tests/unit/query_plan_match_filter_return.cpp +++ b/tests/unit/query_plan_match_filter_return.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -42,6 +42,7 @@ using namespace memgraph::query; using namespace memgraph::query::plan; +using memgraph::replication::ReplicationRole; const std::string testSuite = "query_plan_match_filter_return"; @@ -50,7 +51,7 @@ class MatchReturnFixture : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; AstStorage storage; SymbolTable symbol_table; @@ -239,7 +240,7 @@ class QueryPlan : public testing::Test { TYPED_TEST_CASE(QueryPlan, StorageTypes); TYPED_TEST(QueryPlan, MatchReturnCartesian) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); ASSERT_TRUE(dba.InsertVertex().AddLabel(dba.NameToLabel("l1")).HasValue()); @@ -263,7 +264,7 @@ TYPED_TEST(QueryPlan, MatchReturnCartesian) { } TYPED_TEST(QueryPlan, StandaloneReturn) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add a few nodes to the database @@ -285,7 +286,7 @@ TYPED_TEST(QueryPlan, StandaloneReturn) { } TYPED_TEST(QueryPlan, NodeFilterLabelsAndProperties) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add a few nodes to the database @@ -337,7 +338,7 @@ TYPED_TEST(QueryPlan, NodeFilterLabelsAndProperties) { } TYPED_TEST(QueryPlan, NodeFilterMultipleLabels) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add a few nodes to the database @@ -382,7 +383,7 @@ TYPED_TEST(QueryPlan, NodeFilterMultipleLabels) { } TYPED_TEST(QueryPlan, Cartesian) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto add_vertex = [&dba](std::string label) { @@ -419,7 +420,7 @@ TYPED_TEST(QueryPlan, Cartesian) { } TYPED_TEST(QueryPlan, CartesianEmptySet) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -439,7 +440,7 @@ TYPED_TEST(QueryPlan, CartesianEmptySet) { } TYPED_TEST(QueryPlan, CartesianThreeWay) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto add_vertex = [&dba](std::string label) { auto vertex = dba.InsertVertex(); @@ -489,7 +490,7 @@ class ExpandFixture : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; SymbolTable symbol_table; AstStorage storage; @@ -649,7 +650,7 @@ class QueryPlanExpandVariable : public testing::Test { memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; // labels for layers in the double chain std::vector labels; @@ -1804,7 +1805,7 @@ class QueryPlanExpandWeightedShortestPath : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; std::pair prop = PROPERTY_PAIR(dba, "property"); memgraph::storage::EdgeTypeId edge_type = dba.NameToEdgeType("edge_type"); @@ -2248,7 +2249,7 @@ class QueryPlanExpandAllShortestPaths : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; std::pair prop = PROPERTY_PAIR(dba, "property"); memgraph::storage::EdgeTypeId edge_type = dba.NameToEdgeType("edge_type"); @@ -2699,7 +2700,7 @@ TYPED_TEST(QueryPlanExpandAllShortestPaths, BasicWithFineGrainedFiltering) { #endif TYPED_TEST(QueryPlan, ExpandOptional) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -2750,7 +2751,7 @@ TYPED_TEST(QueryPlan, ExpandOptional) { } TYPED_TEST(QueryPlan, OptionalMatchEmptyDB) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -2767,7 +2768,7 @@ TYPED_TEST(QueryPlan, OptionalMatchEmptyDB) { } TYPED_TEST(QueryPlan, OptionalMatchEmptyDBExpandFromNode) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; // OPTIONAL MATCH (n) @@ -2790,7 +2791,7 @@ TYPED_TEST(QueryPlan, OptionalMatchEmptyDBExpandFromNode) { } TYPED_TEST(QueryPlan, OptionalMatchThenExpandToMissingNode) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Make a graph with 2 connected, unlabeled nodes. auto v1 = dba.InsertVertex(); @@ -2834,7 +2835,7 @@ TYPED_TEST(QueryPlan, OptionalMatchThenExpandToMissingNode) { } TYPED_TEST(QueryPlan, ExpandExistingNode) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // make a graph (v1)->(v2) that @@ -2872,7 +2873,7 @@ TYPED_TEST(QueryPlan, ExpandExistingNode) { TYPED_TEST(QueryPlan, ExpandBothCycleEdgeCase) { // we're testing that expanding on BOTH // does only one expansion for a cycle - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v = dba.InsertVertex(); @@ -2889,7 +2890,7 @@ TYPED_TEST(QueryPlan, ExpandBothCycleEdgeCase) { } TYPED_TEST(QueryPlan, EdgeFilter) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // make an N-star expanding from (v1) @@ -2949,7 +2950,7 @@ TYPED_TEST(QueryPlan, EdgeFilter) { } TYPED_TEST(QueryPlan, EdgeFilterMultipleTypes) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -2979,7 +2980,7 @@ TYPED_TEST(QueryPlan, EdgeFilterMultipleTypes) { } TYPED_TEST(QueryPlan, Filter) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // add a 6 nodes with property 'prop', 2 have true as value @@ -3003,7 +3004,7 @@ TYPED_TEST(QueryPlan, Filter) { } TYPED_TEST(QueryPlan, EdgeUniquenessFilter) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // make a graph that has (v1)->(v2) and a recursive edge (v1)->(v1) @@ -3038,7 +3039,7 @@ TYPED_TEST(QueryPlan, Distinct) { // test queries like // UNWIND [1, 2, 3, 3] AS x RETURN DISTINCT x - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); SymbolTable symbol_table; @@ -3082,11 +3083,11 @@ TYPED_TEST(QueryPlan, Distinct) { TYPED_TEST(QueryPlan, ScanAllByLabel) { auto label = this->db->NameToLabel("label"); { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Add a vertex with a label and one without. auto labeled_vertex = dba.InsertVertex(); @@ -3133,7 +3134,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelProperty) { memgraph::storage::PropertyValue( std::vector{memgraph::storage::PropertyValue(2)})}; { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); for (const auto &value : values) { auto vertex = dba.InsertVertex(); @@ -3144,12 +3145,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelProperty) { } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); ASSERT_EQ(14, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); @@ -3243,7 +3244,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyEqualityNoError) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto number_vertex = dba.InsertVertex(); ASSERT_TRUE(number_vertex.AddLabel(label).HasValue()); @@ -3254,12 +3255,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyEqualityNoError) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(2, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); // MATCH (n :label {prop: 42}) @@ -3283,7 +3284,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyValueError) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); for (int i = 0; i < 2; ++i) { auto vertex = dba.InsertVertex(); @@ -3293,12 +3294,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyValueError) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(2, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); // MATCH (m), (n :label {prop: m}) @@ -3316,7 +3317,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyRangeError) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); for (int i = 0; i < 2; ++i) { auto vertex = dba.InsertVertex(); @@ -3326,12 +3327,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyRangeError) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(2, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); // MATCH (m), (n :label {prop: m}) @@ -3372,7 +3373,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyEqualNull) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto vertex = dba.InsertVertex(); ASSERT_TRUE(vertex.AddLabel(label).HasValue()); @@ -3382,12 +3383,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyEqualNull) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(2, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); // MATCH (n :label {prop: 42}) @@ -3409,7 +3410,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyRangeNull) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto vertex = dba.InsertVertex(); ASSERT_TRUE(vertex.AddLabel(label).HasValue()); @@ -3419,12 +3420,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyRangeNull) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(2, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); // MATCH (n :label) WHERE null <= n.prop < null @@ -3444,7 +3445,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyNoValueInIndexContinuation) { auto label = this->db->NameToLabel("label"); auto prop = this->db->NameToProperty("prop"); { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v = dba.InsertVertex(); ASSERT_TRUE(v.AddLabel(label).HasValue()); @@ -3452,12 +3453,12 @@ TYPED_TEST(QueryPlan, ScanAllByLabelPropertyNoValueInIndexContinuation) { ASSERT_FALSE(dba.Commit().HasError()); } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(1, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); @@ -3487,7 +3488,7 @@ TYPED_TEST(QueryPlan, ScanAllEqualsScanAllByLabelProperty) { const int prop_value1 = 42, prop_value2 = 69; for (int i = 0; i < vertex_count; ++i) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v = dba.InsertVertex(); ASSERT_TRUE(v.AddLabel(label).HasValue()); @@ -3497,14 +3498,14 @@ TYPED_TEST(QueryPlan, ScanAllEqualsScanAllByLabelProperty) { } { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); [[maybe_unused]] auto _ = unique_acc->CreateIndex(label, prop); ASSERT_FALSE(unique_acc->Commit().HasError()); } // Make sure there are `vertex_count` vertices { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); EXPECT_EQ(vertex_count, CountIterable(dba.Vertices(memgraph::storage::View::OLD))); } @@ -3512,7 +3513,7 @@ TYPED_TEST(QueryPlan, ScanAllEqualsScanAllByLabelProperty) { // Make sure there are `vertex_prop_count` results when using index auto count_with_index = [this, &label, &prop](int prop_value, int prop_count) { SymbolTable symbol_table; - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto scan_all_by_label_property_value = MakeScanAllByLabelPropertyValue(this->storage, symbol_table, "n", label, prop, "prop", LITERAL(prop_value)); @@ -3526,7 +3527,7 @@ TYPED_TEST(QueryPlan, ScanAllEqualsScanAllByLabelProperty) { // Make sure there are `vertex_count` results when using scan all auto count_with_scan_all = [this, &prop](int prop_value, int prop_count) { SymbolTable symbol_table; - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto scan_all = MakeScanAll(this->storage, symbol_table, "n"); auto e = PROPERTY_LOOKUP(dba, IDENT("n")->MapTo(scan_all.sym_), std::make_pair("prop", prop)); @@ -3551,7 +3552,7 @@ class ExistsFixture : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; AstStorage storage; SymbolTable symbol_table; @@ -3779,7 +3780,7 @@ class SubqueriesFeature : public testing::Test { protected: memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{db->Access(ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; AstStorage storage; SymbolTable symbol_table; diff --git a/tests/unit/query_plan_operator_to_string.cpp b/tests/unit/query_plan_operator_to_string.cpp index 27d27f0d1..4430e6d23 100644 --- a/tests/unit/query_plan_operator_to_string.cpp +++ b/tests/unit/query_plan_operator_to_string.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -37,7 +37,7 @@ class OperatorToStringTest : public ::testing::Test { OperatorToStringTest() : config(disk_test_utils::GenerateOnDiskConfig(testSuite)), db(new StorageType(config)), - dba_storage(db->Access()), + dba_storage(db->Access(memgraph::replication::ReplicationRole::MAIN)), dba(dba_storage.get()) {} ~OperatorToStringTest() override { diff --git a/tests/unit/query_plan_read_write_typecheck.cpp b/tests/unit/query_plan_read_write_typecheck.cpp index a369f44b9..99b3c3da7 100644 --- a/tests/unit/query_plan_read_write_typecheck.cpp +++ b/tests/unit/query_plan_read_write_typecheck.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -36,7 +36,8 @@ class ReadWriteTypeCheckTest : public ::testing::Test { memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr dba_storage{db->Access()}; + std::unique_ptr dba_storage{ + db->Access(memgraph::replication::ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{dba_storage.get()}; void TearDown() override { diff --git a/tests/unit/query_plan_v2_create_set_remove_delete.cpp b/tests/unit/query_plan_v2_create_set_remove_delete.cpp index 7aeeb4e5e..c6a7b3627 100644 --- a/tests/unit/query_plan_v2_create_set_remove_delete.cpp +++ b/tests/unit/query_plan_v2_create_set_remove_delete.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +18,7 @@ #include "query/plan/operator.hpp" #include "storage/v2/disk/storage.hpp" #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; template class QueryPlan : public testing::Test { @@ -37,7 +38,7 @@ using StorageTypes = ::testing::Typesdb->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); auto label = memgraph::storage::LabelId::FromInt(42); auto property = memgraph::storage::PropertyId::FromInt(1); @@ -75,7 +76,7 @@ TYPED_TEST(QueryPlan, CreateNodeWithAttributes) { TYPED_TEST(QueryPlan, ScanAllEmpty) { memgraph::query::AstStorage ast; memgraph::query::SymbolTable symbol_table; - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); DbAccessor execution_dba(dba.get()); auto node_symbol = symbol_table.CreateSymbol("n", true); { @@ -100,13 +101,13 @@ TYPED_TEST(QueryPlan, ScanAllEmpty) { TYPED_TEST(QueryPlan, ScanAll) { { - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); for (int i = 0; i < 42; ++i) dba->CreateVertex(); EXPECT_FALSE(dba->Commit().HasError()); } memgraph::query::AstStorage ast; memgraph::query::SymbolTable symbol_table; - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); DbAccessor execution_dba(dba.get()); auto node_symbol = symbol_table.CreateSymbol("n", true); memgraph::query::plan::ScanAll scan_all(nullptr, node_symbol); @@ -121,12 +122,12 @@ TYPED_TEST(QueryPlan, ScanAll) { TYPED_TEST(QueryPlan, ScanAllByLabel) { auto label = this->db->NameToLabel("label"); { - auto unique_acc = this->db->UniqueAccess(); + auto unique_acc = this->db->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); // Add some unlabeled vertices for (int i = 0; i < 12; ++i) dba->CreateVertex(); // Add labeled vertices @@ -136,7 +137,7 @@ TYPED_TEST(QueryPlan, ScanAllByLabel) { } EXPECT_FALSE(dba->Commit().HasError()); } - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::AstStorage ast; memgraph::query::SymbolTable symbol_table; auto node_symbol = symbol_table.CreateSymbol("n", true); diff --git a/tests/unit/query_pretty_print.cpp b/tests/unit/query_pretty_print.cpp index 1b19f8aa8..4382176be 100644 --- a/tests/unit/query_pretty_print.cpp +++ b/tests/unit/query_pretty_print.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -36,7 +36,8 @@ class ExpressionPrettyPrinterTest : public ::testing::Test { const std::string testSuite = "query_pretty_print"; memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{ + db->Access(memgraph::replication::ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; AstStorage storage; diff --git a/tests/unit/query_procedure_mgp_type.cpp b/tests/unit/query_procedure_mgp_type.cpp index c5f30f3af..9018d5997 100644 --- a/tests/unit/query_procedure_mgp_type.cpp +++ b/tests/unit/query_procedure_mgp_type.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -23,6 +23,8 @@ #include "disk_test_utils.hpp" #include "test_utils.hpp" +using memgraph::replication::ReplicationRole; + template class CypherType : public testing::Test { public: @@ -244,7 +246,7 @@ TYPED_TEST(CypherType, MapSatisfiesType) { } TYPED_TEST(CypherType, VertexSatisfiesType) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto vertex = dba.InsertVertex(); mgp_memory memory{memgraph::utils::NewDeleteResource()}; @@ -267,7 +269,7 @@ TYPED_TEST(CypherType, VertexSatisfiesType) { } TYPED_TEST(CypherType, EdgeSatisfiesType) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); auto v2 = dba.InsertVertex(); @@ -291,7 +293,7 @@ TYPED_TEST(CypherType, EdgeSatisfiesType) { } TYPED_TEST(CypherType, PathSatisfiesType) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); auto v2 = dba.InsertVertex(); diff --git a/tests/unit/query_procedure_py_module.cpp b/tests/unit/query_procedure_py_module.cpp index dd744229a..90d9cb669 100644 --- a/tests/unit/query_procedure_py_module.cpp +++ b/tests/unit/query_procedure_py_module.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -21,6 +21,8 @@ #include "storage/v2/inmemory/storage.hpp" #include "test_utils.hpp" +using memgraph::replication::ReplicationRole; + template class PyModule : public testing::Test { public: @@ -116,7 +118,7 @@ static void AssertPickleAndCopyAreNotSupported(PyObject *py_obj) { TYPED_TEST(PyModule, PyVertex) { // Initialize the database with 2 vertices and 1 edge. { - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); auto v1 = dba->CreateVertex(); auto v2 = dba->CreateVertex(); @@ -129,7 +131,7 @@ TYPED_TEST(PyModule, PyVertex) { ASSERT_FALSE(dba->Commit().HasError()); } // Get the first vertex as an mgp_value. - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); mgp_memory memory{memgraph::utils::NewDeleteResource()}; mgp_graph graph{&dba, memgraph::storage::View::OLD, nullptr, dba.GetStorageMode()}; @@ -165,7 +167,7 @@ TYPED_TEST(PyModule, PyVertex) { TYPED_TEST(PyModule, PyEdge) { // Initialize the database with 2 vertices and 1 edge. { - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); auto v1 = dba->CreateVertex(); auto v2 = dba->CreateVertex(); @@ -179,7 +181,7 @@ TYPED_TEST(PyModule, PyEdge) { ASSERT_FALSE(dba->Commit().HasError()); } // Get the edge as an mgp_value. - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); mgp_memory memory{memgraph::utils::NewDeleteResource()}; mgp_graph graph{&dba, memgraph::storage::View::OLD, nullptr, dba.GetStorageMode()}; @@ -219,13 +221,13 @@ TYPED_TEST(PyModule, PyEdge) { TYPED_TEST(PyModule, PyPath) { { - auto dba = this->db->Access(); + auto dba = this->db->Access(ReplicationRole::MAIN); auto v1 = dba->CreateVertex(); auto v2 = dba->CreateVertex(); ASSERT_TRUE(dba->CreateEdge(&v1, &v2, dba->NameToEdgeType("type")).HasValue()); ASSERT_FALSE(dba->Commit().HasError()); } - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); mgp_memory memory{memgraph::utils::NewDeleteResource()}; mgp_graph graph{&dba, memgraph::storage::View::OLD, nullptr, dba.GetStorageMode()}; diff --git a/tests/unit/query_procedures_mgp_graph.cpp b/tests/unit/query_procedures_mgp_graph.cpp index 785aab2cf..22ea64cfd 100644 --- a/tests/unit/query_procedures_mgp_graph.cpp +++ b/tests/unit/query_procedures_mgp_graph.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -34,6 +34,8 @@ #include "utils/memory.hpp" #include "utils/variant_helpers.hpp" +using memgraph::replication::ReplicationRole; + #define EXPECT_SUCCESS(...) EXPECT_EQ(__VA_ARGS__, mgp_error::MGP_ERROR_NO_ERROR) namespace { @@ -155,7 +157,7 @@ class MgpGraphTest : public ::testing::Test { } memgraph::query::DbAccessor &CreateDbAccessor(const memgraph::storage::IsolationLevel isolationLevel) { - accessors_.push_back(storage->Access(isolationLevel)); + accessors_.push_back(storage->Access(ReplicationRole::MAIN, isolationLevel)); db_accessors_.emplace_back(accessors_.back().get()); return db_accessors_.back(); } @@ -194,7 +196,8 @@ TYPED_TEST(MgpGraphTest, CreateVertex) { return; } mgp_graph graph = this->CreateGraph(); - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); EXPECT_EQ(CountVertices(*read_uncommited_accessor, memgraph::storage::View::NEW), 0); MgpVertexPtr vertex{EXPECT_MGP_NO_ERROR(mgp_vertex *, mgp_graph_create_vertex, &graph, &this->memory)}; EXPECT_NE(vertex, nullptr); @@ -217,7 +220,8 @@ TYPED_TEST(MgpGraphTest, DeleteVertex) { ASSERT_FALSE(accessor.Commit().HasError()); } mgp_graph graph = this->CreateGraph(); - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); EXPECT_EQ(CountVertices(*read_uncommited_accessor, memgraph::storage::View::NEW), 1); MgpVertexPtr vertex{EXPECT_MGP_NO_ERROR(mgp_vertex *, mgp_graph_get_vertex_by_id, &graph, mgp_vertex_id{vertex_id.AsInt()}, &this->memory)}; @@ -233,7 +237,8 @@ TYPED_TEST(MgpGraphTest, DetachDeleteVertex) { } const auto vertex_ids = this->CreateEdge(); auto graph = this->CreateGraph(); - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); EXPECT_EQ(CountVertices(*read_uncommited_accessor, memgraph::storage::View::NEW), 2); MgpVertexPtr vertex{EXPECT_MGP_NO_ERROR(mgp_vertex *, mgp_graph_get_vertex_by_id, &graph, mgp_vertex_id{vertex_ids.front().AsInt()}, &this->memory)}; @@ -255,7 +260,8 @@ TYPED_TEST(MgpGraphTest, CreateDeleteWithImmutableGraph) { vertex_id = vertex.Gid(); ASSERT_FALSE(accessor.Commit().HasError()); } - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); EXPECT_EQ(CountVertices(*read_uncommited_accessor, memgraph::storage::View::NEW), 1); mgp_graph immutable_graph = this->CreateGraph(memgraph::storage::View::OLD); @@ -326,7 +332,8 @@ TYPED_TEST(MgpGraphTest, VertexSetProperty) { ASSERT_TRUE(result.HasValue()); ASSERT_FALSE(accessor.Commit().HasError()); } - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); EXPECT_EQ(CountVertices(*read_uncommited_accessor, memgraph::storage::View::NEW), 1); mgp_graph graph = this->CreateGraph(memgraph::storage::View::NEW); @@ -396,7 +403,8 @@ TYPED_TEST(MgpGraphTest, VertexAddLabel) { auto check_label = [&]() { EXPECT_NE(EXPECT_MGP_NO_ERROR(int, mgp_vertex_has_label_named, vertex.get(), label.data()), 0); - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); const auto maybe_vertex = read_uncommited_accessor->FindVertex(vertex_id, memgraph::storage::View::NEW); ASSERT_TRUE(maybe_vertex); const auto label_ids = maybe_vertex->Labels(memgraph::storage::View::NEW); @@ -433,7 +441,8 @@ TYPED_TEST(MgpGraphTest, VertexRemoveLabel) { auto check_label = [&]() { EXPECT_EQ(EXPECT_MGP_NO_ERROR(int, mgp_vertex_has_label_named, vertex.get(), label.data()), 0); - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); const auto maybe_vertex = read_uncommited_accessor->FindVertex(vertex_id, memgraph::storage::View::NEW); ASSERT_TRUE(maybe_vertex); const auto label_ids = maybe_vertex->Labels(memgraph::storage::View::NEW); @@ -622,14 +631,15 @@ TYPED_TEST(MgpGraphTest, EdgeSetProperty) { { const auto vertex_ids = this->CreateEdge(); from_vertex_id = vertex_ids[0]; - auto accessor = this->storage->Access(memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); + auto accessor = this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION); auto edge = get_edge(accessor.get()); const auto result = edge.SetProperty(accessor->NameToProperty(property_to_update), memgraph::storage::PropertyValue(42)); ASSERT_TRUE(result.HasValue()); ASSERT_FALSE(accessor->Commit().HasError()); } - auto read_uncommited_accessor = this->storage->Access(memgraph::storage::IsolationLevel::READ_UNCOMMITTED); + auto read_uncommited_accessor = + this->storage->Access(ReplicationRole::MAIN, memgraph::storage::IsolationLevel::READ_UNCOMMITTED); mgp_graph graph = this->CreateGraph(memgraph::storage::View::NEW); MgpEdgePtr edge; diff --git a/tests/unit/query_semantic.cpp b/tests/unit/query_semantic.cpp index 5d015f103..4f27fa1e2 100644 --- a/tests/unit/query_semantic.cpp +++ b/tests/unit/query_semantic.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -34,7 +34,8 @@ class TestSymbolGenerator : public ::testing::Test { const std::string testSuite = "query_semantic"; memgraph::storage::Config config = disk_test_utils::GenerateOnDiskConfig(testSuite); std::unique_ptr db{new StorageType(config)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{ + db->Access(memgraph::replication::ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; AstStorage storage; diff --git a/tests/unit/query_trigger.cpp b/tests/unit/query_trigger.cpp index 0eb9602c3..040af0a22 100644 --- a/tests/unit/query_trigger.cpp +++ b/tests/unit/query_trigger.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -29,6 +29,8 @@ #include "utils/exceptions.hpp" #include "utils/memory.hpp" +using memgraph::replication::ReplicationRole; + namespace { const std::unordered_set kAllEventTypes{ memgraph::query::TriggerEventType::ANY, memgraph::query::TriggerEventType::VERTEX_CREATE, @@ -69,7 +71,7 @@ class TriggerContextTest : public ::testing::Test { } memgraph::storage::Storage::Accessor *StartTransaction() { - accessors.emplace_back(db->Access()); + accessors.emplace_back(db->Access(ReplicationRole::MAIN)); return accessors.back().get(); } @@ -902,7 +904,7 @@ class TriggerStoreTest : public ::testing::Test { config = disk_test_utils::GenerateOnDiskConfig(testSuite); storage = std::make_unique(config); - storage_accessor = storage->Access(); + storage_accessor = storage->Access(ReplicationRole::MAIN); dba.emplace(storage_accessor.get()); } diff --git a/tests/unit/query_variable_start_planner.cpp b/tests/unit/query_variable_start_planner.cpp index b9772c2d3..ef08e8cca 100644 --- a/tests/unit/query_variable_start_planner.cpp +++ b/tests/unit/query_variable_start_planner.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -28,6 +28,7 @@ #include "formatters.hpp" +using memgraph::replication::ReplicationRole; using namespace memgraph::query::plan; using memgraph::query::AstStorage; using Type = memgraph::query::EdgeAtom::Type; @@ -110,7 +111,7 @@ using StorageTypes = ::testing::Typesdb->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Make a graph (v1) -[:r]-> (v2) auto v1 = dba.InsertVertex(); @@ -127,7 +128,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchReturn) { } TYPED_TEST(TestVariableStartPlanner, MatchTripletPatternReturn) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Make a graph (v1) -[:r]-> (v2) -[:r]-> (v3) auto v1 = dba.InsertVertex(); @@ -159,7 +160,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchTripletPatternReturn) { } TYPED_TEST(TestVariableStartPlanner, MatchOptionalMatchReturn) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Make a graph (v1) -[:r]-> (v2) -[:r]-> (v3) auto v1 = dba.InsertVertex(); @@ -186,7 +187,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchOptionalMatchReturn) { } TYPED_TEST(TestVariableStartPlanner, MatchOptionalMatchMergeReturn) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Graph (v1) -[:r]-> (v2) memgraph::query::VertexAccessor v1(dba.InsertVertex()); @@ -210,7 +211,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchOptionalMatchMergeReturn) { } TYPED_TEST(TestVariableStartPlanner, MatchWithMatchReturn) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Graph (v1) -[:r]-> (v2) memgraph::query::VertexAccessor v1(dba.InsertVertex()); @@ -230,7 +231,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchWithMatchReturn) { } TYPED_TEST(TestVariableStartPlanner, MatchVariableExpand) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); // Graph (v1) -[:r1]-> (v2) -[:r2]-> (v3) auto v1 = dba.InsertVertex(); @@ -253,7 +254,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchVariableExpand) { } TYPED_TEST(TestVariableStartPlanner, MatchVariableExpandReferenceNode) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto id = dba.NameToProperty("id"); // Graph (v1 {id:1}) -[:r1]-> (v2 {id: 2}) -[:r2]-> (v3 {id: 3}) @@ -281,7 +282,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchVariableExpandReferenceNode) { } TYPED_TEST(TestVariableStartPlanner, MatchVariableExpandBoth) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto id = dba.NameToProperty("id"); // Graph (v1 {id:1}) -[:r1]-> (v2) -[:r2]-> (v3) @@ -307,7 +308,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchVariableExpandBoth) { } TYPED_TEST(TestVariableStartPlanner, MatchBfs) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto id = dba.NameToProperty("id"); // Graph (v1 {id:1}) -[:r1]-> (v2 {id: 2}) -[:r2]-> (v3 {id: 3}) @@ -334,7 +335,7 @@ TYPED_TEST(TestVariableStartPlanner, MatchBfs) { } TYPED_TEST(TestVariableStartPlanner, TestBasicSubquery) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -356,7 +357,7 @@ TYPED_TEST(TestVariableStartPlanner, TestBasicSubquery) { } TYPED_TEST(TestVariableStartPlanner, TestBasicSubqueryWithMatching) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto v1 = dba.InsertVertex(); @@ -377,7 +378,7 @@ TYPED_TEST(TestVariableStartPlanner, TestBasicSubqueryWithMatching) { } TYPED_TEST(TestVariableStartPlanner, TestSubqueryWithUnion) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto id = dba.NameToProperty("id"); @@ -405,7 +406,7 @@ TYPED_TEST(TestVariableStartPlanner, TestSubqueryWithUnion) { } TYPED_TEST(TestVariableStartPlanner, TestSubqueryWithTripleUnion) { - auto storage_dba = this->db->Access(); + auto storage_dba = this->db->Access(ReplicationRole::MAIN); memgraph::query::DbAccessor dba(storage_dba.get()); auto id = dba.NameToProperty("id"); diff --git a/tests/unit/storage_rocks.cpp b/tests/unit/storage_rocks.cpp index 6d5db7d75..365f46ad3 100644 --- a/tests/unit/storage_rocks.cpp +++ b/tests/unit/storage_rocks.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +30,8 @@ #include "storage/v2/view.hpp" #include "utils/rocksdb_serialization.hpp" +using memgraph::replication::ReplicationRole; + // NOLINTNEXTLINE(google-build-using-namespace) using namespace memgraph::storage; @@ -57,14 +59,14 @@ class RocksDBStorageTest : public ::testing::TestWithParam { }; TEST_F(RocksDBStorageTest, SerializeVertexGID) { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); auto gid = vertex.Gid(); ASSERT_EQ(memgraph::utils::SerializeVertex(*vertex.vertex_), "|" + gid.ToString()); } TEST_F(RocksDBStorageTest, SerializeVertexGIDLabels) { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); auto ser_player_label = acc->NameToLabel("Player"); auto ser_user_label = acc->NameToLabel("User"); diff --git a/tests/unit/storage_v2.cpp b/tests/unit/storage_v2.cpp index 74ac5b3fa..dc3ec1512 100644 --- a/tests/unit/storage_v2.cpp +++ b/tests/unit/storage_v2.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -23,6 +23,8 @@ #include "storage/v2/vertex_accessor.hpp" #include "storage_test_utils.hpp" +using memgraph::replication::ReplicationRole; + using testing::Types; using testing::UnorderedElementsAre; @@ -53,7 +55,7 @@ TYPED_TEST_CASE(StorageV2Test, StorageTypes); TYPED_TEST(StorageV2Test, Commit) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -63,7 +65,7 @@ TYPED_TEST(StorageV2Test, Commit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_TRUE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); EXPECT_EQ(CountVertices(*acc, memgraph::storage::View::OLD), 1U); ASSERT_TRUE(acc->FindVertex(gid, memgraph::storage::View::NEW).has_value()); @@ -71,7 +73,7 @@ TYPED_TEST(StorageV2Test, Commit) { acc->Abort(); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -87,7 +89,7 @@ TYPED_TEST(StorageV2Test, Commit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); EXPECT_EQ(CountVertices(*acc, memgraph::storage::View::OLD), 0U); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::NEW).has_value()); @@ -100,7 +102,7 @@ TYPED_TEST(StorageV2Test, Commit) { TYPED_TEST(StorageV2Test, Abort) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -110,7 +112,7 @@ TYPED_TEST(StorageV2Test, Abort) { acc->Abort(); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); EXPECT_EQ(CountVertices(*acc, memgraph::storage::View::OLD), 0U); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::NEW).has_value()); @@ -124,7 +126,7 @@ TYPED_TEST(StorageV2Test, AdvanceCommandCommit) { memgraph::storage::Gid gid1 = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); memgraph::storage::Gid gid2 = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -148,7 +150,7 @@ TYPED_TEST(StorageV2Test, AdvanceCommandCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_TRUE(acc->FindVertex(gid1, memgraph::storage::View::OLD).has_value()); ASSERT_TRUE(acc->FindVertex(gid1, memgraph::storage::View::NEW).has_value()); ASSERT_TRUE(acc->FindVertex(gid2, memgraph::storage::View::OLD).has_value()); @@ -164,7 +166,7 @@ TYPED_TEST(StorageV2Test, AdvanceCommandAbort) { memgraph::storage::Gid gid1 = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); memgraph::storage::Gid gid2 = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -188,7 +190,7 @@ TYPED_TEST(StorageV2Test, AdvanceCommandAbort) { acc->Abort(); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_FALSE(acc->FindVertex(gid1, memgraph::storage::View::OLD).has_value()); ASSERT_FALSE(acc->FindVertex(gid1, memgraph::storage::View::NEW).has_value()); ASSERT_FALSE(acc->FindVertex(gid2, memgraph::storage::View::OLD).has_value()); @@ -201,8 +203,8 @@ TYPED_TEST(StorageV2Test, AdvanceCommandAbort) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(StorageV2Test, SnapshotIsolation) { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->CreateVertex(); auto gid = vertex.Gid(); @@ -223,7 +225,7 @@ TYPED_TEST(StorageV2Test, SnapshotIsolation) { acc2->Abort(); - auto acc3 = this->store->Access(); + auto acc3 = this->store->Access(ReplicationRole::MAIN); ASSERT_TRUE(acc3->FindVertex(gid, memgraph::storage::View::OLD).has_value()); EXPECT_EQ(CountVertices(*acc3, memgraph::storage::View::OLD), 1U); ASSERT_TRUE(acc3->FindVertex(gid, memgraph::storage::View::NEW).has_value()); @@ -235,7 +237,7 @@ TYPED_TEST(StorageV2Test, SnapshotIsolation) { TYPED_TEST(StorageV2Test, AccessorMove) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); @@ -254,7 +256,7 @@ TYPED_TEST(StorageV2Test, AccessorMove) { ASSERT_FALSE(moved->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_TRUE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); EXPECT_EQ(CountVertices(*acc, memgraph::storage::View::OLD), 1U); ASSERT_TRUE(acc->FindVertex(gid, memgraph::storage::View::NEW).has_value()); @@ -266,8 +268,8 @@ TYPED_TEST(StorageV2Test, AccessorMove) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(StorageV2Test, VertexDeleteCommit) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); - auto acc1 = this->store->Access(); // read transaction - auto acc2 = this->store->Access(); // write transaction + auto acc1 = this->store->Access(ReplicationRole::MAIN); // read transaction + auto acc2 = this->store->Access(ReplicationRole::MAIN); // write transaction // Create the vertex in transaction 2 { @@ -280,8 +282,8 @@ TYPED_TEST(StorageV2Test, VertexDeleteCommit) { ASSERT_FALSE(acc2->Commit().HasError()); } - auto acc3 = this->store->Access(); // read transaction - auto acc4 = this->store->Access(); // write transaction + auto acc3 = this->store->Access(ReplicationRole::MAIN); // read transaction + auto acc4 = this->store->Access(ReplicationRole::MAIN); // write transaction // Check whether the vertex exists in transaction 1 ASSERT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -314,7 +316,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteCommit) { ASSERT_FALSE(acc4->Commit().HasError()); } - auto acc5 = this->store->Access(); // read transaction + auto acc5 = this->store->Access(ReplicationRole::MAIN); // read transaction // Check whether the vertex exists in transaction 1 ASSERT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -339,8 +341,8 @@ TYPED_TEST(StorageV2Test, VertexDeleteCommit) { TYPED_TEST(StorageV2Test, VertexDeleteAbort) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); - auto acc1 = this->store->Access(); // read transaction - auto acc2 = this->store->Access(); // write transaction + auto acc1 = this->store->Access(ReplicationRole::MAIN); // read transaction + auto acc2 = this->store->Access(ReplicationRole::MAIN); // write transaction // Create the vertex in transaction 2 { @@ -353,8 +355,8 @@ TYPED_TEST(StorageV2Test, VertexDeleteAbort) { ASSERT_FALSE(acc2->Commit().HasError()); } - auto acc3 = this->store->Access(); // read transaction - auto acc4 = this->store->Access(); // write transaction (aborted) + auto acc3 = this->store->Access(ReplicationRole::MAIN); // read transaction + auto acc4 = this->store->Access(ReplicationRole::MAIN); // write transaction (aborted) // Check whether the vertex exists in transaction 1 ASSERT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -387,8 +389,8 @@ TYPED_TEST(StorageV2Test, VertexDeleteAbort) { acc4->Abort(); } - auto acc5 = this->store->Access(); // read transaction - auto acc6 = this->store->Access(); // write transaction + auto acc5 = this->store->Access(ReplicationRole::MAIN); // read transaction + auto acc6 = this->store->Access(ReplicationRole::MAIN); // write transaction // Check whether the vertex exists in transaction 1 ASSERT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -427,7 +429,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteAbort) { ASSERT_FALSE(acc6->Commit().HasError()); } - auto acc7 = this->store->Access(); // read transaction + auto acc7 = this->store->Access(ReplicationRole::MAIN); // read transaction // Check whether the vertex exists in transaction 1 ASSERT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -466,14 +468,14 @@ TYPED_TEST(StorageV2Test, VertexDeleteSerializationError) { // Create vertex { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); } - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); // Delete vertex in accessor 1 { @@ -546,7 +548,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteSerializationError) { // Check whether the vertex exists { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_FALSE(vertex); EXPECT_EQ(CountVertices(*acc, memgraph::storage::View::OLD), 0U); @@ -563,7 +565,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteSpecialCases) { // Create vertex and delete it in the same transaction, but abort the // transaction { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid1 = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid1, memgraph::storage::View::OLD).has_value()); @@ -583,7 +585,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteSpecialCases) { // Create vertex and delete it in the same transaction { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid2 = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid2, memgraph::storage::View::OLD).has_value()); @@ -603,7 +605,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteSpecialCases) { // Check whether the vertices exist { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); ASSERT_FALSE(acc->FindVertex(gid1, memgraph::storage::View::OLD).has_value()); ASSERT_FALSE(acc->FindVertex(gid1, memgraph::storage::View::NEW).has_value()); ASSERT_FALSE(acc->FindVertex(gid2, memgraph::storage::View::OLD).has_value()); @@ -620,7 +622,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteLabel) { // Create the vertex { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -630,7 +632,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteLabel) { // Add label, delete the vertex and check the label API (same command) { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -684,7 +686,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteLabel) { // Add label, delete the vertex and check the label API (different command) { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -775,7 +777,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteProperty) { // Create the vertex { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD).has_value()); @@ -785,7 +787,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteProperty) { // Set property, delete the vertex and check the property API (same command) { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -833,7 +835,7 @@ TYPED_TEST(StorageV2Test, VertexDeleteProperty) { // Set property, delete the vertex and check the property API (different // command) { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -916,7 +918,7 @@ TYPED_TEST(StorageV2Test, VertexLabelCommit) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); @@ -948,7 +950,7 @@ TYPED_TEST(StorageV2Test, VertexLabelCommit) { spdlog::debug("Commit done"); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -977,7 +979,7 @@ TYPED_TEST(StorageV2Test, VertexLabelCommit) { spdlog::debug("Abort done"); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1009,7 +1011,7 @@ TYPED_TEST(StorageV2Test, VertexLabelCommit) { spdlog::debug("Commit done"); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1036,7 +1038,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Create the vertex. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1044,7 +1046,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Add label 5, but abort the transaction. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1077,7 +1079,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Check that label 5 doesn't exist. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1098,7 +1100,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Add label 5. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1131,7 +1133,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Check that label 5 exists. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1161,7 +1163,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Remove label 5, but abort the transaction. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1194,7 +1196,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Check that label 5 exists. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1224,7 +1226,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Remove label 5. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1257,7 +1259,7 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { // Check that label 5 doesn't exist. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1281,14 +1283,14 @@ TYPED_TEST(StorageV2Test, VertexLabelAbort) { TYPED_TEST(StorageV2Test, VertexLabelSerializationError) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); } - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); // Add label 1 in accessor 1. { @@ -1371,7 +1373,7 @@ TYPED_TEST(StorageV2Test, VertexLabelSerializationError) { // Check which labels exist. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1402,7 +1404,7 @@ TYPED_TEST(StorageV2Test, VertexLabelSerializationError) { TYPED_TEST(StorageV2Test, VertexPropertyCommit) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); @@ -1440,7 +1442,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1468,7 +1470,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyCommit) { acc->Abort(); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1499,7 +1501,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1525,7 +1527,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Create the vertex. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1533,7 +1535,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Set property 5 to "nandare", but abort the transaction. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1573,7 +1575,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Check that property 5 is null. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1594,7 +1596,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Set property 5 to "nandare". { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1634,7 +1636,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Check that property 5 is "nandare". { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1664,7 +1666,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Set property 5 to null, but abort the transaction. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1705,7 +1707,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Check that property 5 is "nandare". { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1735,7 +1737,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Set property 5 to null. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1776,7 +1778,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { // Check that property 5 is null. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1800,14 +1802,14 @@ TYPED_TEST(StorageV2Test, VertexPropertyAbort) { TYPED_TEST(StorageV2Test, VertexPropertySerializationError) { memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); } - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); // Set property 1 to 123 in accessor 1. { @@ -1884,7 +1886,7 @@ TYPED_TEST(StorageV2Test, VertexPropertySerializationError) { // Check which properties exist. { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1913,7 +1915,7 @@ TYPED_TEST(StorageV2Test, VertexPropertySerializationError) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(StorageV2Test, VertexLabelPropertyMixed) { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); auto label = acc->NameToLabel("label5"); @@ -2155,7 +2157,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyClear) { auto property1 = this->store->NameToProperty("property1"); auto property2 = this->store->NameToProperty("property2"); { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); @@ -2166,7 +2168,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2198,7 +2200,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyClear) { acc->Abort(); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2209,7 +2211,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2242,7 +2244,7 @@ TYPED_TEST(StorageV2Test, VertexPropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2258,7 +2260,7 @@ TYPED_TEST(StorageV2Test, VertexNonexistentLabelPropertyEdgeAPI) { auto label = this->store->NameToLabel("label"); auto property = this->store->NameToProperty("property"); - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); // Check state before (OLD view). @@ -2314,8 +2316,8 @@ TYPED_TEST(StorageV2Test, VertexNonexistentLabelPropertyEdgeAPI) { } TYPED_TEST(StorageV2Test, VertexVisibilitySingleTransaction) { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->CreateVertex(); auto gid = vertex.Gid(); @@ -2334,7 +2336,7 @@ TYPED_TEST(StorageV2Test, VertexVisibilitySingleTransaction) { ASSERT_TRUE(vertex.SetProperty(acc1->NameToProperty("meaning"), memgraph::storage::PropertyValue(42)).HasValue()); - auto acc3 = this->store->Access(); + auto acc3 = this->store->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_TRUE(acc1->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2371,8 +2373,8 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { memgraph::storage::Gid gid; { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->CreateVertex(); gid = vertex.Gid(); @@ -2401,8 +2403,8 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { } { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2435,7 +2437,7 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { ASSERT_TRUE(vertex->SetProperty(acc1->NameToProperty("meaning"), memgraph::storage::PropertyValue(42)).HasValue()); - auto acc3 = this->store->Access(); + auto acc3 = this->store->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc1->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_TRUE(acc1->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2477,15 +2479,15 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { } { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE(acc1->DeleteVertex(&*vertex).HasValue()); - auto acc3 = this->store->Access(); + auto acc3 = this->store->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc1->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2527,7 +2529,7 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_TRUE(acc->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2541,15 +2543,15 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { } { - auto acc1 = this->store->Access(); - auto acc2 = this->store->Access(); + auto acc1 = this->store->Access(ReplicationRole::MAIN); + auto acc2 = this->store->Access(ReplicationRole::MAIN); auto vertex = acc1->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE(acc1->DeleteVertex(&*vertex).HasValue()); - auto acc3 = this->store->Access(); + auto acc3 = this->store->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc1->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_FALSE(acc1->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2591,7 +2593,7 @@ TYPED_TEST(StorageV2Test, VertexVisibilityMultipleTransactions) { } { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->FindVertex(gid, memgraph::storage::View::OLD)); EXPECT_FALSE(acc->FindVertex(gid, memgraph::storage::View::NEW)); @@ -2613,14 +2615,14 @@ TYPED_TEST(StorageV2Test, DeletedVertexAccessor) { std::optional gid; // Create the vertex { - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_FALSE(vertex.SetProperty(property, property_value).HasError()); ASSERT_FALSE(acc->Commit().HasError()); } - auto acc = this->store->Access(); + auto acc = this->store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(*gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto maybe_deleted_vertex = acc->DeleteVertex(&*vertex); diff --git a/tests/unit/storage_v2_constraints.cpp b/tests/unit/storage_v2_constraints.cpp index dfee45a0e..b36bc59c9 100644 --- a/tests/unit/storage_v2_constraints.cpp +++ b/tests/unit/storage_v2_constraints.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -23,6 +23,8 @@ #include "disk_test_utils.hpp" +using memgraph::replication::ReplicationRole; + // NOLINTNEXTLINE(google-build-using-namespace) using namespace memgraph::storage; @@ -81,7 +83,7 @@ TYPED_TEST_CASE(ConstraintsTest, StorageTypes); // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllConstraints().existence.size(), 0); ASSERT_NO_ERROR(acc->Commit()); } @@ -92,7 +94,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().existence, UnorderedElementsAre(std::make_pair(this->label1, this->prop1))); ASSERT_NO_ERROR(acc->Commit()); } @@ -103,7 +105,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().existence, UnorderedElementsAre(std::make_pair(this->label1, this->prop1))); ASSERT_NO_ERROR(acc->Commit()); } @@ -114,7 +116,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().existence, UnorderedElementsAre(std::make_pair(this->label1, this->prop1), std::make_pair(this->label2, this->prop1))); ASSERT_NO_ERROR(acc->Commit()); @@ -130,7 +132,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().existence, UnorderedElementsAre(std::make_pair(this->label2, this->prop1))); ASSERT_NO_ERROR(acc->Commit()); } @@ -145,7 +147,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllConstraints().existence.size(), 0); ASSERT_NO_ERROR(acc->Commit()); } @@ -156,7 +158,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().existence, UnorderedElementsAre(std::make_pair(this->label2, this->prop1))); ASSERT_NO_ERROR(acc->Commit()); } @@ -165,7 +167,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateAndDrop) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateFailure1) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(acc->Commit()); @@ -180,7 +182,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateFailure1) { ASSERT_FALSE(unique_acc->Commit().HasError()); // TODO: Check if we are committing here? } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(acc->DeleteVertex(&vertex)); } @@ -197,7 +199,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateFailure1) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateFailure2) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(acc->Commit()); @@ -212,7 +214,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsCreateFailure2) { ASSERT_FALSE(unique_acc->Commit().HasError()); // TODO: Check if we are committing here? } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); } @@ -236,7 +238,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -248,7 +250,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); @@ -256,7 +258,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue())); } @@ -269,7 +271,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue())); } @@ -285,7 +287,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(acc->Commit()); @@ -295,7 +297,7 @@ TYPED_TEST(ConstraintsTest, ExistenceConstraintsViolationOnCommit) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllConstraints().unique.size(), 0); ASSERT_NO_ERROR(acc->Commit()); } @@ -307,7 +309,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label1, std::set{this->prop1}))); ASSERT_NO_ERROR(acc->Commit()); @@ -320,7 +322,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label1, std::set{this->prop1}))); ASSERT_NO_ERROR(acc->Commit()); @@ -333,7 +335,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label1, std::set{this->prop1}), std::make_pair(this->label2, std::set{this->prop1}))); @@ -352,7 +354,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label2, std::set{this->prop1}))); ASSERT_NO_ERROR(acc->Commit()); @@ -370,7 +372,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllConstraints().unique.size(), 0); ASSERT_NO_ERROR(acc->Commit()); } @@ -381,7 +383,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { EXPECT_EQ(res.GetValue(), UniqueConstraints::CreationStatus::SUCCESS); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label2, std::set{this->prop1}))); ASSERT_NO_ERROR(acc->Commit()); @@ -391,7 +393,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateAndDropAndList) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateFailure1) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 2; ++i) { auto vertex1 = acc->CreateVertex(); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); @@ -411,7 +413,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateFailure1) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(acc->DeleteVertex(&vertex)); } @@ -430,7 +432,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateFailure1) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateFailure2) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 2; ++i) { auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -450,7 +452,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsCreateFailure2) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); int value = 0; for (auto vertex : acc->Vertices(View::OLD)) { ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(value))); @@ -473,7 +475,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation1) { Gid gid1; Gid gid2; { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -493,7 +495,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation1) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid1, View::OLD); auto vertex2 = acc->FindVertex(gid2, View::OLD); @@ -505,7 +507,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation1) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid1, View::OLD); auto vertex2 = acc->FindVertex(gid2, View::OLD); ASSERT_NO_ERROR(vertex1->SetProperty(this->prop1, PropertyValue(2))); @@ -528,8 +530,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation2) { // tx1: B---SP(v1, 1)---SP(v1, 2)---OK-- // tx2: -B---SP(v2, 2)---SP(v2, 1)---OK- - auto acc1 = this->storage->Access(); - auto acc2 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto vertex2 = acc2->CreateVertex(); @@ -561,7 +563,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation3) { // tx2: --------------------B---SP(v1, 2)---OK-- // tx3: ---------------------B---SP(v2, 1)---OK- - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto gid = vertex1.Gid(); @@ -570,8 +572,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation3) { ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); - auto acc3 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(gid, View::NEW); // vertex1 == vertex2 auto vertex3 = acc3->CreateVertex(); @@ -599,7 +601,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation4) { // tx2: --------------------B---SP(v2, 1)-----OK- // tx3: ---------------------B---SP(v1, 2)---OK-- - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto gid = vertex1.Gid(); @@ -607,8 +609,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsNoViolation4) { ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); - auto acc3 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->CreateVertex(); auto vertex3 = acc3->FindVertex(gid, View::NEW); @@ -632,7 +634,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsViolationOnCommit1) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); @@ -663,7 +665,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsViolationOnCommit2) { // tx2: -------------------------------B---SP(v1, 3)---OK---- // tx3: --------------------------------B---SP(v2, 3)---FAIL- - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto vertex2 = acc1->CreateVertex(); auto gid1 = vertex1.Gid(); @@ -676,8 +678,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsViolationOnCommit2) { ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); - auto acc3 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex3 = acc2->FindVertex(gid1, View::NEW); // vertex3 == vertex1 auto vertex4 = acc3->FindVertex(gid2, View::NEW); // vertex4 == vertex2 @@ -709,7 +711,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsViolationOnCommit3) { // tx2: -------------------------------B---SP(v1, 2)---FAIL-- // tx3: --------------------------------B---SP(v2, 1)---FAIL- - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->CreateVertex(); auto vertex2 = acc1->CreateVertex(); auto gid1 = vertex1.Gid(); @@ -722,8 +724,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsViolationOnCommit3) { ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); - auto acc3 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex3 = acc2->FindVertex(gid1, View::OLD); // vertex3 == vertex1 auto vertex4 = acc3->FindVertex(gid2, View::OLD); // vertex4 == vertex2 @@ -762,7 +764,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsLabelAlteration) { { // B---AL(v2)---SP(v1, 1)---SP(v2, 1)---OK - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -782,8 +784,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsLabelAlteration) { // tx1: B---AL(v1)-----OK- // tx2: -B---RL(v2)---OK-- - auto acc1 = this->storage->Access(); - auto acc2 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->FindVertex(gid1, View::OLD); auto vertex2 = acc2->FindVertex(gid2, View::OLD); @@ -811,7 +813,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsLabelAlteration) { { // B---AL(v2)---FAIL - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc->FindVertex(gid2, View::OLD); ASSERT_NO_ERROR(vertex2->AddLabel(this->label1)); @@ -824,7 +826,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsLabelAlteration) { { // B---RL(v1)---OK - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid1, View::OLD); ASSERT_NO_ERROR(vertex1->RemoveLabel(this->label1)); ASSERT_NO_ERROR(acc->Commit()); @@ -834,8 +836,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsLabelAlteration) { // tx1: B---AL(v1)-----FAIL // tx2: -B---AL(v2)---OK--- - auto acc1 = this->storage->Access(); - auto acc2 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->FindVertex(gid1, View::OLD); auto vertex2 = acc2->FindVertex(gid2, View::OLD); @@ -911,7 +913,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsPropertySetSize) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllConstraints().unique, UnorderedElementsAre(std::make_pair(this->label1, properties))); ASSERT_NO_ERROR(acc->Commit()); } @@ -922,7 +924,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsPropertySetSize) { ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); ASSERT_TRUE(acc->ListAllConstraints().unique.empty()); ASSERT_NO_ERROR(acc->Commit()); } @@ -951,7 +953,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsMultipleProperties) { Gid gid1; Gid gid2; { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -971,7 +973,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsMultipleProperties) { // Try to change property of the second vertex so it becomes the same as the // first vertex-> It should fail. { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc->FindVertex(gid2, View::OLD); ASSERT_NO_ERROR(vertex2->SetProperty(this->prop2, PropertyValue(2))); auto res = acc->Commit(); @@ -985,7 +987,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsMultipleProperties) { // both vertices should now be equal. However, this operation should succeed // since null value is treated as non-existing property. { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid1, View::OLD); auto vertex2 = acc->FindVertex(gid2, View::OLD); ASSERT_NO_ERROR(vertex1->SetProperty(this->prop2, PropertyValue())); @@ -1005,7 +1007,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertAbortInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); @@ -1014,7 +1016,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertAbortInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop2, PropertyValue(2))); @@ -1034,7 +1036,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertRemoveInsert) { Gid gid; { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -1044,14 +1046,14 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertRemoveInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, View::OLD); ASSERT_NO_ERROR(acc->DeleteVertex(&*vertex)); ASSERT_NO_ERROR(acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); @@ -1071,7 +1073,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertRemoveAbortInsert) { Gid gid; { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -1081,14 +1083,14 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertRemoveAbortInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, View::OLD); ASSERT_NO_ERROR(acc->DeleteVertex(&*vertex)); acc->Abort(); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop2, PropertyValue(1))); @@ -1114,7 +1116,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsDeleteVertexSetProperty) { Gid gid1; Gid gid2; { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); gid1 = vertex1.Gid(); @@ -1129,8 +1131,8 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsDeleteVertexSetProperty) { } { - auto acc1 = this->storage->Access(); - auto acc2 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = acc1->FindVertex(gid1, View::OLD); auto vertex2 = acc2->FindVertex(gid2, View::OLD); @@ -1156,7 +1158,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertDropInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); @@ -1172,7 +1174,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsInsertDropInsert) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop2, PropertyValue(2))); @@ -1194,7 +1196,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsComparePropertyValues) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(2))); @@ -1203,7 +1205,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsComparePropertyValues) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(1))); @@ -1212,7 +1214,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsComparePropertyValues) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop2, PropertyValue(0))); @@ -1238,7 +1240,7 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsClearOldData) { ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop1, PropertyValue(2))); @@ -1246,14 +1248,14 @@ TYPED_TEST(ConstraintsTest, UniqueConstraintsClearOldData) { ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = this->storage->Access(std::nullopt); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex2.SetProperty(this->prop1, memgraph::storage::PropertyValue(2)).HasValue()); ASSERT_FALSE(acc2->Commit().HasError()); ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc3 = this->storage->Access(std::nullopt); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex3 = acc3->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex3.SetProperty(this->prop1, memgraph::storage::PropertyValue(10)).HasValue()); ASSERT_FALSE(acc3->Commit().HasError()); diff --git a/tests/unit/storage_v2_durability_inmemory.cpp b/tests/unit/storage_v2_durability_inmemory.cpp index 8a6d26fd1..bdec38c00 100644 --- a/tests/unit/storage_v2_durability_inmemory.cpp +++ b/tests/unit/storage_v2_durability_inmemory.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +48,7 @@ #include "utils/timer.hpp" #include "utils/uuid.hpp" +using memgraph::replication::ReplicationRole; using testing::Contains; using testing::UnorderedElementsAre; @@ -93,26 +94,26 @@ class DurabilityTest : public ::testing::TestWithParam { { // Create label index. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label_unindexed).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create label index statistics. - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); acc->SetIndexStats(label_unindexed, memgraph::storage::LabelIndexStats{1, 2}); ASSERT_TRUE(acc->GetIndexStats(label_unindexed)); ASSERT_FALSE(acc->Commit().HasError()); } { // Create label+property index. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label_indexed, property_id).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create label+property index statistics. - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); acc->SetIndexStats(label_indexed, property_id, memgraph::storage::LabelPropertyIndexStats{1, 2, 3.4, 5.6, 0.0}); ASSERT_TRUE(acc->GetIndexStats(label_indexed, property_id)); ASSERT_FALSE(acc->Commit().HasError()); @@ -120,20 +121,20 @@ class DurabilityTest : public ::testing::TestWithParam { { // Create existence constraint. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateExistenceConstraint(label_unindexed, property_id).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create unique constraint. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(label_unindexed, {property_id, property_extra}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } // Create vertices. for (uint64_t i = 0; i < kNumBaseVertices; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); base_vertex_gids_[i] = vertex.Gid(); if (i < kNumBaseVertices / 2) { @@ -150,7 +151,7 @@ class DurabilityTest : public ::testing::TestWithParam { // Create edges. for (uint64_t i = 0; i < kNumBaseEdges; ++i) { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(base_vertex_gids_[(i / 2) % kNumBaseVertices], memgraph::storage::View::OLD); ASSERT_TRUE(vertex1); auto vertex2 = acc->FindVertex(base_vertex_gids_[(i / 3) % kNumBaseVertices], memgraph::storage::View::OLD); @@ -186,26 +187,26 @@ class DurabilityTest : public ::testing::TestWithParam { { // Create label index. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label_unused).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create label index statistics. - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); acc->SetIndexStats(label_unused, memgraph::storage::LabelIndexStats{123, 9.87}); ASSERT_TRUE(acc->GetIndexStats(label_unused)); ASSERT_FALSE(acc->Commit().HasError()); } { // Create label+property index. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(label_indexed, property_count).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create label+property index statistics. - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); acc->SetIndexStats(label_indexed, property_count, memgraph::storage::LabelPropertyIndexStats{456798, 312345, 12312312.2, 123123.2, 67876.9}); ASSERT_TRUE(acc->GetIndexStats(label_indexed, property_count)); @@ -214,25 +215,25 @@ class DurabilityTest : public ::testing::TestWithParam { { // Create existence constraint. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateExistenceConstraint(label_unused, property_count).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { // Create unique constraint. - auto unique_acc = store->UniqueAccess(); + auto unique_acc = store->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(label_unused, {property_count}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } // Storage accessor. std::unique_ptr acc; - if (single_transaction) acc = store->Access(); + if (single_transaction) acc = store->Access(ReplicationRole::MAIN); // Create vertices. for (uint64_t i = 0; i < kNumExtendedVertices; ++i) { - if (!single_transaction) acc = store->Access(); + if (!single_transaction) acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); extended_vertex_gids_[i] = vertex.Gid(); if (i < kNumExtendedVertices / 2) { @@ -246,7 +247,7 @@ class DurabilityTest : public ::testing::TestWithParam { // Create edges. for (uint64_t i = 0; i < kNumExtendedEdges; ++i) { - if (!single_transaction) acc = store->Access(); + if (!single_transaction) acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(extended_vertex_gids_[(i / 5) % kNumExtendedVertices], memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -285,7 +286,7 @@ class DurabilityTest : public ::testing::TestWithParam { auto et4 = store->NameToEdgeType("extended_et4"); // Create storage accessor. - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); // Verify indices info. { @@ -826,7 +827,7 @@ TEST_P(DurabilityTest, SnapshotOnExit) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -863,7 +864,7 @@ TEST_P(DurabilityTest, SnapshotPeriodic) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -933,7 +934,7 @@ TEST_P(DurabilityTest, SnapshotFallback) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -950,7 +951,7 @@ TEST_P(DurabilityTest, SnapshotEverythingCorrupt) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -1035,7 +1036,7 @@ TEST_P(DurabilityTest, SnapshotRetention) { .durability = {.storage_directory = storage_directory, .snapshot_on_exit = true}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -1096,7 +1097,7 @@ TEST_P(DurabilityTest, SnapshotRetention) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1165,7 +1166,7 @@ TEST_P(DurabilityTest, SnapshotMixedUUID) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1181,7 +1182,7 @@ TEST_P(DurabilityTest, SnapshotBackup) { .durability = {.storage_directory = storage_directory, .snapshot_on_exit = true}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -1238,7 +1239,7 @@ TEST_F(DurabilityTest, SnapshotWithoutPropertiesOnEdgesRecoveryWithPropertiesOnE // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1292,7 +1293,7 @@ TEST_F(DurabilityTest, SnapshotWithPropertiesOnEdgesButUnusedRecoveryWithoutProp VerifyDataset(db.storage(), DatasetType::BASE_WITH_EXTENDED, true); // Remove properties from edges. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (auto vertex : acc->Vertices(memgraph::storage::View::OLD)) { auto in_edges = vertex.InEdges(memgraph::storage::View::OLD); ASSERT_TRUE(in_edges.HasValue()); @@ -1333,7 +1334,7 @@ TEST_F(DurabilityTest, SnapshotWithPropertiesOnEdgesButUnusedRecoveryWithoutProp // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1372,7 +1373,7 @@ TEST_P(DurabilityTest, WalBasic) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1394,7 +1395,7 @@ TEST_P(DurabilityTest, WalBackup) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -1485,7 +1486,7 @@ TEST_P(DurabilityTest, WalAppendToExisting) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1509,7 +1510,7 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto v1 = acc->CreateVertex(); gid_v1 = v1.Gid(); auto v2 = acc->CreateVertex(); @@ -1545,7 +1546,7 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto indices = acc->ListAllIndices(); ASSERT_EQ(indices.label.size(), 0); @@ -1628,7 +1629,7 @@ TEST_P(DurabilityTest, WalCreateInSingleTransaction) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1652,39 +1653,39 @@ TEST_P(DurabilityTest, WalCreateAndRemoveEverything) { CreateBaseDataset(db.storage(), GetParam()); CreateExtendedDataset(db.storage()); auto indices = [&] { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto res = acc->ListAllIndices(); acc->Commit(); return res; }(); // iile for (const auto &index : indices.label) { - auto unique_acc = db.storage()->UniqueAccess(); + auto unique_acc = db.UniqueAccess(); ASSERT_FALSE(unique_acc->DropIndex(index).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } for (const auto &index : indices.label_property) { - auto unique_acc = db.storage()->UniqueAccess(); + auto unique_acc = db.UniqueAccess(); ASSERT_FALSE(unique_acc->DropIndex(index.first, index.second).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } auto constraints = [&] { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto res = acc->ListAllConstraints(); acc->Commit(); return res; }(); // iile for (const auto &constraint : constraints.existence) { - auto unique_acc = db.storage()->UniqueAccess(); + auto unique_acc = db.UniqueAccess(); ASSERT_FALSE(unique_acc->DropExistenceConstraint(constraint.first, constraint.second).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } for (const auto &constraint : constraints.unique) { - auto unique_acc = db.storage()->UniqueAccess(); + auto unique_acc = db.UniqueAccess(); ASSERT_EQ(unique_acc->DropUniqueConstraint(constraint.first, constraint.second), memgraph::storage::UniqueConstraints::DeletionStatus::SUCCESS); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (auto vertex : acc->Vertices(memgraph::storage::View::OLD)) { ASSERT_TRUE(acc->DetachDeleteVertex(&vertex).HasValue()); } @@ -1702,7 +1703,7 @@ TEST_P(DurabilityTest, WalCreateAndRemoveEverything) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto indices = acc->ListAllIndices(); ASSERT_EQ(indices.label.size(), 0); ASSERT_EQ(indices.label_property.size(), 0); @@ -1719,7 +1720,7 @@ TEST_P(DurabilityTest, WalCreateAndRemoveEverything) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1745,8 +1746,8 @@ TEST_P(DurabilityTest, WalTransactionOrdering) { }}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc1 = db.storage()->Access(); - auto acc2 = db.storage()->Access(); + auto acc1 = db.Access(); + auto acc2 = db.Access(); // Create vertex in transaction 2. { @@ -1756,7 +1757,7 @@ TEST_P(DurabilityTest, WalTransactionOrdering) { vertex2.SetProperty(db.storage()->NameToProperty("id"), memgraph::storage::PropertyValue(2)).HasValue()); } - auto acc3 = db.storage()->Access(); + auto acc3 = db.Access(); // Create vertex in transaction 3. { @@ -1839,7 +1840,7 @@ TEST_P(DurabilityTest, WalTransactionOrdering) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; { - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (auto [gid, id] : std::vector>{{gid1, 1}, {gid2, 2}, {gid3, 3}}) { auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -1855,7 +1856,7 @@ TEST_P(DurabilityTest, WalTransactionOrdering) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1880,7 +1881,7 @@ TEST_P(DurabilityTest, WalCreateAndRemoveOnlyBaseDataset) { CreateExtendedDataset(db.storage()); auto label_indexed = db.storage()->NameToLabel("base_indexed"); auto label_unindexed = db.storage()->NameToLabel("base_unindexed"); - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (auto vertex : acc->Vertices(memgraph::storage::View::OLD)) { auto has_indexed = vertex.HasLabel(label_indexed, memgraph::storage::View::OLD); ASSERT_TRUE(has_indexed.HasValue()); @@ -1905,7 +1906,7 @@ TEST_P(DurabilityTest, WalCreateAndRemoveOnlyBaseDataset) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -1930,7 +1931,7 @@ TEST_P(DurabilityTest, WalDeathResilience) { memgraph::dbms::Database db{config, repl_state}; // Create one million vertices. for (uint64_t i = 0; i < 1000000; ++i) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); acc->CreateVertex(); MG_ASSERT(!acc->Commit().HasError(), "Couldn't commit transaction!"); } @@ -1968,7 +1969,7 @@ TEST_P(DurabilityTest, WalDeathResilience) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto iterable = acc->Vertices(memgraph::storage::View::OLD); for (auto it = iterable.begin(); it != iterable.end(); ++it) { ++count; @@ -1977,7 +1978,7 @@ TEST_P(DurabilityTest, WalDeathResilience) { } { - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < kExtraItems; ++i) { acc->CreateVertex(); } @@ -1997,7 +1998,7 @@ TEST_P(DurabilityTest, WalDeathResilience) { memgraph::dbms::Database db{config, repl_state}; { uint64_t current = 0; - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto iterable = acc->Vertices(memgraph::storage::View::OLD); for (auto it = iterable.begin(); it != iterable.end(); ++it) { ++current; @@ -2007,7 +2008,7 @@ TEST_P(DurabilityTest, WalDeathResilience) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2029,7 +2030,7 @@ TEST_P(DurabilityTest, WalMissingSecond) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -2059,13 +2060,13 @@ TEST_P(DurabilityTest, WalMissingSecond) { std::vector gids; gids.reserve(kNumVertices); for (uint64_t i = 0; i < kNumVertices; ++i) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); gids.push_back(vertex.Gid()); ASSERT_FALSE(acc->Commit().HasError()); } for (uint64_t i = 0; i < kNumVertices; ++i) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE( @@ -2124,7 +2125,7 @@ TEST_P(DurabilityTest, WalCorruptSecond) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -2154,13 +2155,13 @@ TEST_P(DurabilityTest, WalCorruptSecond) { std::vector gids; gids.reserve(kNumVertices); for (uint64_t i = 0; i < kNumVertices; ++i) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); gids.push_back(vertex.Gid()); ASSERT_FALSE(acc->Commit().HasError()); } for (uint64_t i = 0; i < kNumVertices; ++i) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->FindVertex(gids[i], memgraph::storage::View::OLD); ASSERT_TRUE(vertex); ASSERT_TRUE( @@ -2246,7 +2247,7 @@ TEST_P(DurabilityTest, WalCorruptLastTransaction) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2268,7 +2269,7 @@ TEST_P(DurabilityTest, WalAllOperationsInSingleTransaction) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); ASSERT_TRUE(vertex1.AddLabel(acc->NameToLabel("nandare")).HasValue()); @@ -2314,7 +2315,7 @@ TEST_P(DurabilityTest, WalAllOperationsInSingleTransaction) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; { - auto acc = db.storage()->Access(); + auto acc = db.Access(); uint64_t count = 0; auto iterable = acc->Vertices(memgraph::storage::View::OLD); for (auto it = iterable.begin(); it != iterable.end(); ++it) { @@ -2325,7 +2326,7 @@ TEST_P(DurabilityTest, WalAllOperationsInSingleTransaction) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2365,7 +2366,7 @@ TEST_P(DurabilityTest, WalAndSnapshot) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2428,7 +2429,7 @@ TEST_P(DurabilityTest, WalAndSnapshotAppendToExistingSnapshot) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2496,7 +2497,7 @@ TEST_P(DurabilityTest, WalAndSnapshotAppendToExistingSnapshotAndWal) { memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; VerifyDataset(db.storage(), DatasetType::BASE_WITH_EXTENDED, GetParam()); - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); vertex_gid = vertex.Gid(); if (GetParam()) { @@ -2519,7 +2520,7 @@ TEST_P(DurabilityTest, WalAndSnapshotAppendToExistingSnapshotAndWal) { VerifyDataset(db.storage(), DatasetType::BASE_WITH_EXTENDED, GetParam(), /* verify_info = */ false); { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->FindVertex(vertex_gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto labels = vertex->Labels(memgraph::storage::View::OLD); @@ -2537,7 +2538,7 @@ TEST_P(DurabilityTest, WalAndSnapshotAppendToExistingSnapshotAndWal) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2559,7 +2560,7 @@ TEST_P(DurabilityTest, WalAndSnapshotWalRetention) { .wal_file_flush_every_n_tx = kFlushWalEvery}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -2592,7 +2593,7 @@ TEST_P(DurabilityTest, WalAndSnapshotWalRetention) { memgraph::utils::Timer timer; // Allow at least 6 snapshots to be created. while (timer.Elapsed().count() < 13.0) { - auto acc = db.storage()->Access(); + auto acc = db.Access(); acc->CreateVertex(); ASSERT_FALSE(acc->Commit().HasError()); ++items_created; @@ -2617,7 +2618,7 @@ TEST_P(DurabilityTest, WalAndSnapshotWalRetention) { .durability = {.storage_directory = storage_directory, .recover_on_startup = true}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t j = 0; j < items_created; ++j) { auto vertex = acc->FindVertex(memgraph::storage::Gid::FromUint(j), memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -2654,7 +2655,7 @@ TEST_P(DurabilityTest, SnapshotAndWalMixedUUID) { .snapshot_interval = std::chrono::seconds(2)}}; memgraph::replication::ReplicationState repl_state{memgraph::storage::ReplicationStateRootPath(config)}; memgraph::dbms::Database db{config, repl_state}; - auto acc = db.storage()->Access(); + auto acc = db.Access(); for (uint64_t i = 0; i < 1000; ++i) { acc->CreateVertex(); } @@ -2705,7 +2706,7 @@ TEST_P(DurabilityTest, SnapshotAndWalMixedUUID) { // Try to use the storage. { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); @@ -2744,7 +2745,7 @@ TEST_P(DurabilityTest, ParallelConstraintsRecovery) { memgraph::dbms::Database db{config, repl_state}; VerifyDataset(db.storage(), DatasetType::BASE_WITH_EXTENDED, GetParam()); { - auto acc = db.storage()->Access(); + auto acc = db.Access(); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, db.storage()->NameToEdgeType("et")); ASSERT_TRUE(edge.HasValue()); diff --git a/tests/unit/storage_v2_edge_inmemory.cpp b/tests/unit/storage_v2_edge_inmemory.cpp index 6f3b0da02..befa52462 100644 --- a/tests/unit/storage_v2_edge_inmemory.cpp +++ b/tests/unit/storage_v2_edge_inmemory.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +17,7 @@ #include "storage/v2/inmemory/storage.hpp" #include "storage/v2/storage.hpp" +using memgraph::replication::ReplicationRole; using testing::UnorderedElementsAre; class StorageEdgeTest : public ::testing::TestWithParam {}; @@ -33,7 +34,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -43,7 +44,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -117,7 +118,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -224,7 +225,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_to = vertex_to.Gid(); @@ -234,7 +235,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -302,7 +303,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -396,7 +397,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -404,7 +405,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -462,7 +463,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -543,7 +544,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -553,7 +554,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -621,7 +622,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -650,7 +651,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -718,7 +719,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -813,7 +814,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_to = vertex_to.Gid(); @@ -823,7 +824,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -891,7 +892,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -920,7 +921,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -988,7 +989,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1082,7 +1083,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1090,7 +1091,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1148,7 +1149,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1167,7 +1168,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1225,7 +1226,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1310,7 +1311,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -1320,7 +1321,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1388,7 +1389,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1475,7 +1476,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1542,7 +1543,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1579,7 +1580,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -1589,7 +1590,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1657,7 +1658,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1744,7 +1745,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1811,7 +1812,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1847,7 +1848,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1855,7 +1856,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1913,7 +1914,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1990,7 +1991,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2047,7 +2048,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2074,7 +2075,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -2084,7 +2085,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2152,7 +2153,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2239,7 +2240,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2306,7 +2307,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2393,7 +2394,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2460,7 +2461,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2497,7 +2498,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -2507,7 +2508,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2575,7 +2576,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2662,7 +2663,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2729,7 +2730,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2817,7 +2818,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2884,7 +2885,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2920,7 +2921,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -2928,7 +2929,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2986,7 +2987,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3063,7 +3064,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3120,7 +3121,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3197,7 +3198,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3254,7 +3255,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3281,7 +3282,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); @@ -3330,7 +3331,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3394,7 +3395,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_FALSE(vertex_from); @@ -3421,7 +3422,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); @@ -3548,7 +3549,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -3686,7 +3687,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_FALSE(vertex1); @@ -3751,7 +3752,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); @@ -3800,7 +3801,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Detach delete vertex, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3864,7 +3865,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3905,7 +3906,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3969,7 +3970,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_FALSE(vertex_from); @@ -3996,7 +3997,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); @@ -4123,7 +4124,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Detach delete vertex, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4261,7 +4262,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4439,7 +4440,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4577,7 +4578,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_FALSE(vertex1); @@ -4639,7 +4640,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { new memgraph::storage::InMemoryStorage({.items = {.properties_on_edges = true}})); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -4682,7 +4683,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4711,7 +4712,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4743,7 +4744,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4772,7 +4773,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Create the vertex. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -4785,7 +4786,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to "nandare", but abort the transaction. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4826,7 +4827,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4848,7 +4849,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4889,7 +4890,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4920,7 +4921,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to null, but abort the transaction. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4962,7 +4963,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4993,7 +4994,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5035,7 +5036,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5062,7 +5063,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { new memgraph::storage::InMemoryStorage({.items = {.properties_on_edges = true}})); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5073,8 +5074,8 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { ASSERT_FALSE(acc->Commit().HasError()); } - auto acc1 = store->Access(); - auto acc2 = store->Access(); + auto acc1 = store->Access(ReplicationRole::MAIN); + auto acc2 = store->Access(ReplicationRole::MAIN); // Set property 1 to 123 in accessor 1. { @@ -5139,7 +5140,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { // Check which properties exist. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5174,7 +5175,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { auto property1 = store->NameToProperty("property1"); auto property2 = store->NameToProperty("property2"); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5190,7 +5191,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5223,7 +5224,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5235,7 +5236,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5269,7 +5270,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5288,7 +5289,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { new memgraph::storage::InMemoryStorage({.items = {.properties_on_edges = false}})); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5299,7 +5300,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5330,7 +5331,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5357,7 +5358,7 @@ TEST(StorageWithoutProperties, EdgePropertyClear) { new memgraph::storage::InMemoryStorage({.items = {.properties_on_edges = false}})); memgraph::storage::Gid gid; { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5368,7 +5369,7 @@ TEST(StorageWithoutProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -5385,7 +5386,7 @@ TEST(StorageWithProperties, EdgeNonexistentPropertyAPI) { auto property = store->NameToProperty("property"); - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, acc->NameToEdgeType("edge")); ASSERT_TRUE(edge.HasValue()); diff --git a/tests/unit/storage_v2_edge_ondisk.cpp b/tests/unit/storage_v2_edge_ondisk.cpp index 5d57c784f..57ba1a562 100644 --- a/tests/unit/storage_v2_edge_ondisk.cpp +++ b/tests/unit/storage_v2_edge_ondisk.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +18,7 @@ #include "storage/v2/disk/storage.hpp" #include "storage/v2/storage.hpp" +using memgraph::replication::ReplicationRole; using testing::UnorderedElementsAre; class StorageEdgeTest : public ::testing::TestWithParam {}; @@ -37,7 +38,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -47,7 +48,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -121,7 +122,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -230,7 +231,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_to = vertex_to.Gid(); @@ -240,7 +241,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -308,7 +309,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -404,7 +405,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -412,7 +413,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -470,7 +471,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -553,7 +554,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -563,7 +564,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -631,7 +632,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -660,7 +661,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -728,7 +729,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -825,7 +826,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_to = vertex_to.Gid(); @@ -835,7 +836,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -903,7 +904,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -932,7 +933,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1000,7 +1001,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1096,7 +1097,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1104,7 +1105,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1162,7 +1163,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1181,7 +1182,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1239,7 +1240,7 @@ TEST_P(StorageEdgeTest, EdgeCreateFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1326,7 +1327,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -1336,7 +1337,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1404,7 +1405,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1491,7 +1492,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1558,7 +1559,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1597,7 +1598,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->CreateVertex(); auto vertex_from = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -1607,7 +1608,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1675,7 +1676,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1762,7 +1763,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1829,7 +1830,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -1867,7 +1868,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -1875,7 +1876,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -1933,7 +1934,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2010,7 +2011,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Delete edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2067,7 +2068,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameCommit) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -2096,7 +2097,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -2106,7 +2107,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2174,7 +2175,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2261,7 +2262,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2328,7 +2329,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2415,7 +2416,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2482,7 +2483,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSmallerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2521,7 +2522,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Create vertices { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); gid_from = vertex_from.Gid(); @@ -2531,7 +2532,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2599,7 +2600,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2686,7 +2687,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2753,7 +2754,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2841,7 +2842,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2908,7 +2909,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromLargerAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -2946,7 +2947,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Create vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid_vertex = vertex.Gid(); ASSERT_FALSE(acc->Commit().HasError()); @@ -2954,7 +2955,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Create edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3012,7 +3013,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3089,7 +3090,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Delete the edge, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3146,7 +3147,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3223,7 +3224,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Delete the edge { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3280,7 +3281,7 @@ TEST_P(StorageEdgeTest, EdgeDeleteFromSameAbort) { // Check whether the edge exists { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid_vertex, memgraph::storage::View::NEW); ASSERT_TRUE(vertex); @@ -3309,7 +3310,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); @@ -3358,7 +3359,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3422,7 +3423,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleCommit) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_FALSE(vertex_from); @@ -3451,7 +3452,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); @@ -3578,7 +3579,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -3716,7 +3717,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleCommit) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_FALSE(vertex1); @@ -3783,7 +3784,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->CreateVertex(); auto vertex_to = acc->CreateVertex(); @@ -3832,7 +3833,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Detach delete vertex, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3896,7 +3897,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -3937,7 +3938,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_TRUE(vertex_from); @@ -4001,7 +4002,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteSingleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex_from = acc->FindVertex(gid_from, memgraph::storage::View::NEW); auto vertex_to = acc->FindVertex(gid_to, memgraph::storage::View::NEW); ASSERT_FALSE(vertex_from); @@ -4030,7 +4031,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Create dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->CreateVertex(); auto vertex2 = acc->CreateVertex(); @@ -4157,7 +4158,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Detach delete vertex, but abort the transaction { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4295,7 +4296,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4473,7 +4474,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Detach delete vertex { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_TRUE(vertex1); @@ -4611,7 +4612,7 @@ TEST_P(StorageEdgeTest, VertexDetachDeleteMultipleAbort) { // Check dataset { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex1 = acc->FindVertex(gid_vertex1, memgraph::storage::View::NEW); auto vertex2 = acc->FindVertex(gid_vertex2, memgraph::storage::View::NEW); ASSERT_FALSE(vertex1); @@ -4675,7 +4676,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { std::unique_ptr store(new memgraph::storage::DiskStorage(config)); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -4718,7 +4719,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4748,7 +4749,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4781,7 +4782,7 @@ TEST(StorageWithProperties, EdgePropertyCommit) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4813,7 +4814,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Create the vertex. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -4826,7 +4827,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to "nandare", but abort the transaction. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4868,7 +4869,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); auto edge = vertex->OutEdges(memgraph::storage::View::NEW).GetValue().edges[0]; @@ -4890,7 +4891,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4932,7 +4933,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -4964,7 +4965,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to null, but abort the transaction. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5007,7 +5008,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is "nandare". { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5039,7 +5040,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Set property 5 to null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5082,7 +5083,7 @@ TEST(StorageWithProperties, EdgePropertyAbort) { // Check that property 5 is null. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5112,7 +5113,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { std::unique_ptr store(new memgraph::storage::DiskStorage(config)); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5123,8 +5124,8 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { ASSERT_FALSE(acc->Commit().HasError()); } - auto acc1 = store->Access(); - auto acc2 = store->Access(); + auto acc1 = store->Access(ReplicationRole::MAIN); + auto acc2 = store->Access(ReplicationRole::MAIN); // Set property 1 to 123 in accessor 1. { @@ -5195,7 +5196,7 @@ TEST(StorageWithProperties, EdgePropertySerializationError) { // Check which properties exist. { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5233,7 +5234,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { auto property1 = store->NameToProperty("property1"); auto property2 = store->NameToProperty("property2"); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5249,7 +5250,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5283,7 +5284,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5296,7 +5297,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5331,7 +5332,7 @@ TEST(StorageWithProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5353,7 +5354,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { std::unique_ptr store(new memgraph::storage::DiskStorage(config)); memgraph::storage::Gid gid = memgraph::storage::Gid::FromUint(std::numeric_limits::max()); { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); spdlog::trace("Created vertex with gid: {}", gid.AsInt()); @@ -5365,7 +5366,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5397,7 +5398,7 @@ TEST(StorageWithoutProperties, EdgePropertyAbort) { acc->Abort(); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5427,7 +5428,7 @@ TEST(StorageWithoutProperties, EdgePropertyClear) { std::unique_ptr store(new memgraph::storage::DiskStorage(config)); memgraph::storage::Gid gid; { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); gid = vertex.Gid(); auto et = acc->NameToEdgeType("et5"); @@ -5438,7 +5439,7 @@ TEST(StorageWithoutProperties, EdgePropertyClear) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->FindVertex(gid, memgraph::storage::View::OLD); ASSERT_TRUE(vertex); @@ -5458,7 +5459,7 @@ TEST(StorageWithProperties, EdgeNonexistentPropertyAPI) { auto property = store->NameToProperty("property"); - auto acc = store->Access(); + auto acc = store->Access(ReplicationRole::MAIN); auto vertex = acc->CreateVertex(); auto edge = acc->CreateEdge(&vertex, &vertex, acc->NameToEdgeType("edge")); ASSERT_TRUE(edge.HasValue()); diff --git a/tests/unit/storage_v2_gc.cpp b/tests/unit/storage_v2_gc.cpp index 122558c17..770d570bc 100644 --- a/tests/unit/storage_v2_gc.cpp +++ b/tests/unit/storage_v2_gc.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,6 +14,7 @@ #include "storage/v2/inmemory/storage.hpp" +using memgraph::replication::ReplicationRole; using testing::UnorderedElementsAre; // TODO: The point of these is not to test GC fully, these are just simple @@ -31,7 +32,7 @@ TEST(StorageV2Gc, Sanity) { std::vector vertices; { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); // Create some vertices, but delete some of them immediately. for (uint64_t i = 0; i < 1000; ++i) { auto vertex = acc->CreateVertex(); @@ -63,7 +64,7 @@ TEST(StorageV2Gc, Sanity) { // Verify existing vertices and add labels to some of them. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); for (uint64_t i = 0; i < 1000; ++i) { auto vertex = acc->FindVertex(vertices[i], memgraph::storage::View::OLD); EXPECT_EQ(vertex.has_value(), i % 5 != 0); @@ -101,7 +102,7 @@ TEST(StorageV2Gc, Sanity) { // Add and remove some edges. { - auto acc = storage->Access(); + auto acc = storage->Access(ReplicationRole::MAIN); for (uint64_t i = 0; i < 1000; ++i) { auto from_vertex = acc->FindVertex(vertices[i], memgraph::storage::View::OLD); auto to_vertex = acc->FindVertex(vertices[(i + 1) % 1000], memgraph::storage::View::OLD); @@ -171,13 +172,13 @@ TEST(StorageV2Gc, Indices) { std::make_unique(memgraph::storage::Config{ .gc = {.type = memgraph::storage::Config::Gc::Type::PERIODIC, .interval = std::chrono::milliseconds(100)}})); { - auto unique_acc = storage->UniqueAccess(); + auto unique_acc = storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(storage->NameToLabel("label")).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto acc0 = storage->Access(); + auto acc0 = storage->Access(ReplicationRole::MAIN); for (uint64_t i = 0; i < 1000; ++i) { auto vertex = acc0->CreateVertex(); ASSERT_TRUE(*vertex.AddLabel(acc0->NameToLabel("label"))); @@ -185,9 +186,9 @@ TEST(StorageV2Gc, Indices) { ASSERT_FALSE(acc0->Commit().HasError()); } { - auto acc1 = storage->Access(); + auto acc1 = storage->Access(ReplicationRole::MAIN); - auto acc2 = storage->Access(); + auto acc2 = storage->Access(ReplicationRole::MAIN); for (auto vertex : acc2->Vertices(memgraph::storage::View::OLD)) { ASSERT_TRUE(*vertex.RemoveLabel(acc2->NameToLabel("label"))); } diff --git a/tests/unit/storage_v2_get_info.cpp b/tests/unit/storage_v2_get_info.cpp index bb7d5c0a1..aa864d7cd 100644 --- a/tests/unit/storage_v2_get_info.cpp +++ b/tests/unit/storage_v2_get_info.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,7 @@ // NOLINTNEXTLINE(google-build-using-namespace) using namespace memgraph::storage; - +using memgraph::replication::ReplicationRole; constexpr auto testSuite = "storage_v2_get_info"; const std::filesystem::path storage_directory{std::filesystem::temp_directory_path() / testSuite}; @@ -63,22 +63,22 @@ TYPED_TEST(InfoTest, InfoCheck) { { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateExistenceConstraint(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->DropExistenceConstraint(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto v1 = acc->CreateVertex(); auto v2 = acc->CreateVertex(); auto v3 = acc->CreateVertex(); auto v4 = acc->CreateVertex(); - auto v5 = acc->CreateVertex(); + [[maybe_unused]] auto v5 = acc->CreateVertex(); ASSERT_FALSE(v2.AddLabel(lbl).HasError()); ASSERT_FALSE(v3.AddLabel(lbl).HasError()); @@ -93,49 +93,49 @@ TYPED_TEST(InfoTest, InfoCheck) { } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(lbl).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateIndex(lbl, prop2).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->DropIndex(lbl, prop).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl, {prop2}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl2, {prop}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_FALSE(unique_acc->CreateUniqueConstraint(lbl3, {prop}).HasError()); ASSERT_FALSE(unique_acc->Commit().HasError()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); ASSERT_EQ(unique_acc->DropUniqueConstraint(lbl, {prop2}), memgraph::storage::UniqueConstraints::DeletionStatus::SUCCESS); ASSERT_FALSE(unique_acc->Commit().HasError()); } - StorageInfo info = this->storage->GetInfo(true); // force to use configured directory + StorageInfo info = this->storage->GetInfo(true, ReplicationRole::MAIN); // force to use configured directory ASSERT_EQ(info.vertex_count, 5); ASSERT_EQ(info.edge_count, 2); diff --git a/tests/unit/storage_v2_indices.cpp b/tests/unit/storage_v2_indices.cpp index 142e15522..10ccb7660 100644 --- a/tests/unit/storage_v2_indices.cpp +++ b/tests/unit/storage_v2_indices.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 Memgraph Ltd. // // Use of this software is governed by the Business Source License // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source @@ -25,7 +25,7 @@ // NOLINTNEXTLINE(google-build-using-namespace) using namespace memgraph::storage; - +using memgraph::replication::ReplicationRole; using testing::IsEmpty; using testing::Types; using testing::UnorderedElementsAre; @@ -39,7 +39,7 @@ class IndexTest : public testing::Test { void SetUp() override { config_ = disk_test_utils::GenerateOnDiskConfig(testSuite); this->storage = std::make_unique(config_); - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); this->prop_id = acc->NameToProperty("id"); this->prop_val = acc->NameToProperty("val"); this->label1 = acc->NameToLabel("label1"); @@ -89,13 +89,13 @@ TYPED_TEST_CASE(IndexTest, StorageTypes); // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelIndexCreate) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelIndexExists(this->label1)); EXPECT_EQ(acc->ListAllIndices().label.size(), 0); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 10; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 2 ? this->label1 : this->label2)); @@ -104,19 +104,19 @@ TYPED_TEST(IndexTest, LabelIndexCreate) { } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), UnorderedElementsAre(1, 3, 5, 7, 9)); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(1, 3, 5, 7, 9)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 10; i < 20; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 2 ? this->label1 : this->label2)); @@ -138,7 +138,7 @@ TYPED_TEST(IndexTest, LabelIndexCreate) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 10; i < 20; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 2 ? this->label1 : this->label2)); @@ -159,7 +159,7 @@ TYPED_TEST(IndexTest, LabelIndexCreate) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), UnorderedElementsAre(1, 3, 5, 7, 9, 21, 23, 25, 27, 29)); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::NEW), View::NEW), @@ -179,13 +179,13 @@ TYPED_TEST(IndexTest, LabelIndexCreate) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelIndexDrop) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelIndexExists(this->label1)); EXPECT_EQ(acc->ListAllIndices().label.size(), 0); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 10; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 2 ? this->label1 : this->label2)); @@ -194,41 +194,41 @@ TYPED_TEST(IndexTest, LabelIndexDrop) { } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), UnorderedElementsAre(1, 3, 5, 7, 9)); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(1, 3, 5, 7, 9)); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->DropIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelIndexExists(this->label1)); EXPECT_EQ(acc->ListAllIndices().label.size(), 0); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_TRUE(unique_acc->DropIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelIndexExists(this->label1)); EXPECT_EQ(acc->ListAllIndices().label.size(), 0); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 10; i < 20; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 2 ? this->label1 : this->label2)); @@ -237,18 +237,18 @@ TYPED_TEST(IndexTest, LabelIndexDrop) { } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc->LabelIndexExists(this->label1)); EXPECT_THAT(acc->ListAllIndices().label, UnorderedElementsAre(this->label1)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), UnorderedElementsAre(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)); @@ -274,17 +274,17 @@ TYPED_TEST(IndexTest, LabelIndexBasic) { // vertices. // 4. Delete even numbered vertices. { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllIndices().label, UnorderedElementsAre(this->label1, this->label2)); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), IsEmpty()); EXPECT_THAT(this->GetIds(acc->Vertices(this->label2, View::OLD), View::OLD), IsEmpty()); @@ -347,18 +347,18 @@ TYPED_TEST(IndexTest, LabelIndexDuplicateVersions) { // the same vertex in the index (they only differ by the timestamp). This test // checks that duplicates are properly filtered out. { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 5; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -370,7 +370,7 @@ TYPED_TEST(IndexTest, LabelIndexDuplicateVersions) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, View::OLD), View::OLD), UnorderedElementsAre(0, 1, 2, 3, 4)); for (auto vertex : acc->Vertices(View::OLD)) { @@ -395,19 +395,19 @@ TYPED_TEST(IndexTest, LabelIndexDuplicateVersions) { TYPED_TEST(IndexTest, LabelIndexTransactionalIsolation) { // Check that transactions only see entries they are supposed to see. { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc_before = this->storage->Access(); - auto acc = this->storage->Access(); - auto acc_after = this->storage->Access(); + auto acc_before = this->storage->Access(ReplicationRole::MAIN); + auto acc = this->storage->Access(ReplicationRole::MAIN); + auto acc_after = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 5; ++i) { auto vertex = this->CreateVertex(acc.get()); @@ -422,7 +422,7 @@ TYPED_TEST(IndexTest, LabelIndexTransactionalIsolation) { ASSERT_NO_ERROR(acc->Commit()); - auto acc_after_commit = this->storage->Access(); + auto acc_after_commit = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc_before->Vertices(this->label1, View::NEW), View::NEW), IsEmpty()); @@ -436,17 +436,17 @@ TYPED_TEST(IndexTest, LabelIndexTransactionalIsolation) { TYPED_TEST(IndexTest, LabelIndexCountEstimate) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 20; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(i % 3 ? this->label1 : this->label2)); @@ -460,23 +460,23 @@ TYPED_TEST(IndexTest, LabelIndexCountEstimate) { TYPED_TEST(IndexTest, LabelIndexDeletedVertex) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); auto vertex2 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex2.AddLabel(this->label1)); EXPECT_THAT(this->GetIds(acc1->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex_to_delete = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto res = acc2->DeleteVertex(&*vertex_to_delete); ASSERT_FALSE(res.HasError()); ASSERT_NO_ERROR(acc2->Commit()); - auto acc3 = this->storage->Access(); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc3->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(1)); } } @@ -484,23 +484,23 @@ TYPED_TEST(IndexTest, LabelIndexDeletedVertex) { TYPED_TEST(IndexTest, LabelIndexRemoveIndexedLabel) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); auto vertex2 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex2.AddLabel(this->label1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc2->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); auto vertex_to_delete = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto res = vertex_to_delete->RemoveLabel(this->label1); ASSERT_FALSE(res.HasError()); ASSERT_NO_ERROR(acc2->Commit()); - auto acc3 = this->storage->Access(); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc3->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(1)); } } @@ -508,17 +508,17 @@ TYPED_TEST(IndexTest, LabelIndexRemoveIndexedLabel) { TYPED_TEST(IndexTest, LabelIndexRemoveAndAddIndexedLabel) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); auto vertex2 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex2.AddLabel(this->label1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc2->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); auto vertex_to_delete = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto res_remove = vertex_to_delete->RemoveLabel(this->label1); @@ -526,7 +526,7 @@ TYPED_TEST(IndexTest, LabelIndexRemoveAndAddIndexedLabel) { auto res_add = vertex_to_delete->AddLabel(this->label1); ASSERT_FALSE(res_add.HasError()); ASSERT_NO_ERROR(acc2->Commit()); - auto acc3 = this->storage->Access(); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc3->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); } } @@ -537,11 +537,11 @@ TYPED_TEST(IndexTest, LabelIndexClearOldDataFromDisk) { static_cast(this->storage->indices_.label_index_.get()); { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop_val, PropertyValue(10))); @@ -550,14 +550,14 @@ TYPED_TEST(IndexTest, LabelIndexClearOldDataFromDisk) { auto *tx_db = disk_label_index->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = this->storage->Access(std::nullopt); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex2.SetProperty(this->prop_val, memgraph::storage::PropertyValue(10)).HasValue()); ASSERT_FALSE(acc2->Commit().HasError()); ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc3 = this->storage->Access(std::nullopt); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex3 = acc3->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex3.SetProperty(this->prop_val, memgraph::storage::PropertyValue(15)).HasValue()); ASSERT_FALSE(acc3->Commit().HasError()); @@ -569,92 +569,92 @@ TYPED_TEST(IndexTest, LabelIndexClearOldDataFromDisk) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelPropertyIndexCreateAndDrop) { { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllIndices().label_property.size(), 0); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc->LabelPropertyIndexExists(this->label1, this->prop_id)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllIndices().label_property, UnorderedElementsAre(std::make_pair(this->label1, this->prop_id))); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelPropertyIndexExists(this->label2, this->prop_id)); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_TRUE(unique_acc->CreateIndex(this->label1, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllIndices().label_property, UnorderedElementsAre(std::make_pair(this->label1, this->prop_id))); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_TRUE(acc->LabelPropertyIndexExists(this->label2, this->prop_id)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT( acc->ListAllIndices().label_property, UnorderedElementsAre(std::make_pair(this->label1, this->prop_id), std::make_pair(this->label2, this->prop_id))); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->DropIndex(this->label1, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelPropertyIndexExists(this->label1, this->prop_id)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(acc->ListAllIndices().label_property, UnorderedElementsAre(std::make_pair(this->label2, this->prop_id))); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_TRUE(unique_acc->DropIndex(this->label1, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->DropIndex(this->label2, this->prop_id).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_FALSE(acc->LabelPropertyIndexExists(this->label2, this->prop_id)); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_EQ(acc->ListAllIndices().label_property.size(), 0); } } @@ -667,17 +667,17 @@ TYPED_TEST(IndexTest, LabelPropertyIndexCreateAndDrop) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelPropertyIndexBasic) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label2, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, this->prop_val, View::OLD), View::OLD), IsEmpty()); for (int i = 0; i < 10; ++i) { @@ -762,13 +762,13 @@ TYPED_TEST(IndexTest, LabelPropertyIndexBasic) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelPropertyIndexDuplicateVersions) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 5; ++i) { auto vertex = this->CreateVertex(acc.get()); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); @@ -782,7 +782,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexDuplicateVersions) { } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, this->prop_val, View::OLD), View::OLD), UnorderedElementsAre(0, 1, 2, 3, 4)); @@ -809,14 +809,14 @@ TYPED_TEST(IndexTest, LabelPropertyIndexDuplicateVersions) { // NOLINTNEXTLINE(hicpp-special-member-functions) TYPED_TEST(IndexTest, LabelPropertyIndexTransactionalIsolation) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc_before = this->storage->Access(); - auto acc = this->storage->Access(); - auto acc_after = this->storage->Access(); + auto acc_before = this->storage->Access(ReplicationRole::MAIN); + auto acc = this->storage->Access(ReplicationRole::MAIN); + auto acc_after = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 5; ++i) { auto vertex = this->CreateVertex(acc.get()); @@ -833,7 +833,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexTransactionalIsolation) { ASSERT_NO_ERROR(acc->Commit()); - auto acc_after_commit = this->storage->Access(); + auto acc_after_commit = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc_before->Vertices(this->label1, this->prop_val, View::NEW), View::NEW), IsEmpty()); @@ -852,13 +852,13 @@ TYPED_TEST(IndexTest, LabelPropertyIndexFiltering) { // properly. { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 10; ++i) { auto vertex = this->CreateVertex(acc.get()); @@ -868,7 +868,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexFiltering) { ASSERT_NO_ERROR(acc->Commit()); } { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 0; i < 5; ++i) { EXPECT_THAT(this->GetIds(acc->Vertices(this->label1, this->prop_val, PropertyValue(i), View::OLD)), UnorderedElementsAre(2 * i, 2 * i + 1)); @@ -926,12 +926,12 @@ TYPED_TEST(IndexTest, LabelPropertyIndexFiltering) { TYPED_TEST(IndexTest, LabelPropertyIndexCountEstimate) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (int i = 1; i <= 10; ++i) { for (int j = 0; j < i; ++j) { auto vertex = this->CreateVertex(acc.get()); @@ -954,7 +954,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexCountEstimate) { TYPED_TEST(IndexTest, LabelPropertyIndexMixedIteration) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } @@ -993,7 +993,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexMixedIteration) { // Create vertices, each with one of the values above. { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); for (const auto &value : values) { auto v = acc->CreateVertex(); ASSERT_TRUE(v.AddLabel(this->label1).HasValue()); @@ -1004,7 +1004,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexMixedIteration) { // Verify that all nodes are in the index. { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto iterable = acc->Vertices(this->label1, this->prop_val, View::OLD); auto it = iterable.begin(); for (const auto &value : values) { @@ -1021,7 +1021,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexMixedIteration) { auto verify = [&](const std::optional> &from, const std::optional> &to, const std::vector &expected) { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(ReplicationRole::MAIN); auto iterable = acc->Vertices(this->label1, this->prop_val, from, to, View::OLD); size_t i = 0; for (auto it = iterable.begin(); it != iterable.end(); ++it, ++i) { @@ -1166,11 +1166,11 @@ TYPED_TEST(IndexTest, LabelPropertyIndexMixedIteration) { TYPED_TEST(IndexTest, LabelPropertyIndexDeletedVertex) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); @@ -1183,13 +1183,13 @@ TYPED_TEST(IndexTest, LabelPropertyIndexDeletedVertex) { EXPECT_THAT(this->GetIds(acc1->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex_to_delete = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto res = acc2->DeleteVertex(&*vertex_to_delete); ASSERT_FALSE(res.HasError()); ASSERT_NO_ERROR(acc2->Commit()); - auto acc3 = this->storage->Access(); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc3->Vertices(this->label1, this->prop_val, View::NEW), View::NEW), UnorderedElementsAre(1)); } @@ -1199,11 +1199,11 @@ TYPED_TEST(IndexTest, LabelPropertyIndexDeletedVertex) { TYPED_TEST(IndexTest, LabelPropertyIndexRemoveIndexedLabel) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); @@ -1216,13 +1216,13 @@ TYPED_TEST(IndexTest, LabelPropertyIndexRemoveIndexedLabel) { EXPECT_THAT(this->GetIds(acc1->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex_to_delete = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto res = vertex_to_delete->RemoveLabel(this->label1); ASSERT_FALSE(res.HasError()); ASSERT_NO_ERROR(acc2->Commit()); - auto acc3 = this->storage->Access(); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); EXPECT_THAT(this->GetIds(acc3->Vertices(this->label1, this->prop_val, View::NEW), View::NEW), UnorderedElementsAre(1)); } @@ -1231,11 +1231,11 @@ TYPED_TEST(IndexTest, LabelPropertyIndexRemoveIndexedLabel) { TYPED_TEST(IndexTest, LabelPropertyIndexRemoveAndAddIndexedLabel) { if constexpr ((std::is_same_v)) { { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex1 = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex1.AddLabel(this->label1)); @@ -1248,7 +1248,7 @@ TYPED_TEST(IndexTest, LabelPropertyIndexRemoveAndAddIndexedLabel) { EXPECT_THAT(this->GetIds(acc1->Vertices(this->label1, View::NEW), View::NEW), UnorderedElementsAre(0, 1)); ASSERT_NO_ERROR(acc1->Commit()); - auto acc2 = this->storage->Access(); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto target_vertex = acc2->FindVertex(vertex1.Gid(), memgraph::storage::View::NEW); auto remove_res = target_vertex->RemoveLabel(this->label1); ASSERT_FALSE(remove_res.HasError()); @@ -1264,11 +1264,11 @@ TYPED_TEST(IndexTest, LabelPropertyIndexClearOldDataFromDisk) { static_cast(this->storage->indices_.label_property_index_.get()); { - auto unique_acc = this->storage->UniqueAccess(); + auto unique_acc = this->storage->UniqueAccess(ReplicationRole::MAIN); EXPECT_FALSE(unique_acc->CreateIndex(this->label1, this->prop_val).HasError()); ASSERT_NO_ERROR(unique_acc->Commit()); } - auto acc1 = this->storage->Access(); + auto acc1 = this->storage->Access(ReplicationRole::MAIN); auto vertex = this->CreateVertex(acc1.get()); ASSERT_NO_ERROR(vertex.AddLabel(this->label1)); ASSERT_NO_ERROR(vertex.SetProperty(this->prop_val, PropertyValue(10))); @@ -1277,14 +1277,14 @@ TYPED_TEST(IndexTest, LabelPropertyIndexClearOldDataFromDisk) { auto *tx_db = disk_label_property_index->GetRocksDBStorage()->db_; ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc2 = this->storage->Access(std::nullopt); + auto acc2 = this->storage->Access(ReplicationRole::MAIN); auto vertex2 = acc2->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex2.SetProperty(this->prop_val, memgraph::storage::PropertyValue(10)).HasValue()); ASSERT_FALSE(acc2->Commit().HasError()); ASSERT_EQ(disk_test_utils::GetRealNumberOfEntriesInRocksDB(tx_db), 1); - auto acc3 = this->storage->Access(std::nullopt); + auto acc3 = this->storage->Access(ReplicationRole::MAIN); auto vertex3 = acc3->FindVertex(vertex.Gid(), memgraph::storage::View::NEW).value(); ASSERT_TRUE(vertex3.SetProperty(this->prop_val, memgraph::storage::PropertyValue(15)).HasValue()); ASSERT_FALSE(acc3->Commit().HasError()); diff --git a/tests/unit/storage_v2_isolation_level.cpp b/tests/unit/storage_v2_isolation_level.cpp index d2ae14d8f..5efedf7f9 100644 --- a/tests/unit/storage_v2_isolation_level.cpp +++ b/tests/unit/storage_v2_isolation_level.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 "storage/v2/inmemory/storage.hpp" #include "storage/v2/isolation_level.hpp" #include "utils/on_scope_exit.hpp" +using memgraph::replication::ReplicationRole; namespace { int64_t VerticesCount(memgraph::storage::Storage::Accessor *accessor) { @@ -44,9 +45,9 @@ class StorageIsolationLevelTest : public ::testing::TestWithParam &storage, const memgraph::storage::IsolationLevel &default_isolation_level, const memgraph::storage::IsolationLevel &override_isolation_level) { - auto creator = storage->Access(); - auto default_isolation_level_reader = storage->Access(); - auto override_isolation_level_reader = storage->Access(override_isolation_level); + auto creator = storage->Access(ReplicationRole::MAIN); + auto default_isolation_level_reader = storage->Access(ReplicationRole::MAIN); + auto override_isolation_level_reader = storage->Access(ReplicationRole::MAIN, override_isolation_level); ASSERT_EQ(VerticesCount(default_isolation_level_reader.get()), 0); ASSERT_EQ(VerticesCount(override_isolation_level_reader.get()), 0); @@ -89,7 +90,7 @@ class StorageIsolationLevelTest : public ::testing::TestWithParamCommit().HasError()); SCOPED_TRACE("Visibility after a new transaction is started"); - auto verifier = storage->Access(); + auto verifier = storage->Access(ReplicationRole::MAIN); ASSERT_EQ(VerticesCount(verifier.get()), iteration_count); ASSERT_FALSE(verifier->Commit().HasError()); } diff --git a/tests/unit/storage_v2_replication.cpp b/tests/unit/storage_v2_replication.cpp index f07130c4a..9399b7ba0 100644 --- a/tests/unit/storage_v2_replication.cpp +++ b/tests/unit/storage_v2_replication.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -458,18 +458,18 @@ TEST_F(ReplicationTest, MultipleSynchronousReplicationTest) { ASSERT_FALSE(acc->Commit().HasError()); } - const auto check_replica = [&](Storage *replica_store) { - auto acc = replica_store->Access(); + const auto check_replica = [&](memgraph::dbms::Database &replica_database) { + auto acc = replica_database.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_TRUE(v); const auto labels = v->Labels(View::OLD); ASSERT_TRUE(labels.HasValue()); - ASSERT_THAT(*labels, UnorderedElementsAre(replica_store->NameToLabel(vertex_label))); + ASSERT_THAT(*labels, UnorderedElementsAre(replica_database.storage()->NameToLabel(vertex_label))); ASSERT_FALSE(acc->Commit().HasError()); }; - check_replica(replica1.db.storage()); - check_replica(replica2.db.storage()); + check_replica(replica1.db); + check_replica(replica2.db); auto handler = main.repl_handler; handler.UnregisterReplica(replicas[1]); @@ -482,7 +482,7 @@ TEST_F(ReplicationTest, MultipleSynchronousReplicationTest) { // REPLICA1 should contain the new vertex { - auto acc = replica1.db.storage()->Access(); + auto acc = replica1.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_TRUE(v); ASSERT_FALSE(acc->Commit().HasError()); @@ -490,7 +490,7 @@ TEST_F(ReplicationTest, MultipleSynchronousReplicationTest) { // REPLICA2 should not contain the new vertex { - auto acc = replica2.db.storage()->Access(); + auto acc = replica2.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_FALSE(v); ASSERT_FALSE(acc->Commit().HasError()); @@ -677,7 +677,7 @@ TEST_F(ReplicationTest, BasicAsynchronousReplicationTest) { } ASSERT_TRUE(std::all_of(created_vertices.begin(), created_vertices.end(), [&](const auto vertex_gid) { - auto acc = replica_async.db.storage()->Access(); + auto acc = replica_async.db.Access(); auto v = acc->FindVertex(vertex_gid, View::OLD); const bool exists = v.has_value(); EXPECT_FALSE(acc->Commit().HasError()); @@ -726,13 +726,13 @@ TEST_F(ReplicationTest, EpochTest) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = replica1.db.storage()->Access(); + auto acc = replica1.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_TRUE(v); ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = replica2.db.storage()->Access(); + auto acc = replica2.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_TRUE(v); ASSERT_FALSE(acc->Commit().HasError()); @@ -759,14 +759,14 @@ TEST_F(ReplicationTest, EpochTest) { ASSERT_FALSE(acc->Commit().HasError()); } { - auto acc = replica1.db.storage()->Access(); + auto acc = replica1.db.Access(); auto v = acc->CreateVertex(); vertex_gid.emplace(v.Gid()); ASSERT_FALSE(acc->Commit().HasError()); } // Replica1 should forward it's vertex to Replica2 { - auto acc = replica2.db.storage()->Access(); + auto acc = replica2.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_TRUE(v); ASSERT_FALSE(acc->Commit().HasError()); @@ -795,7 +795,7 @@ TEST_F(ReplicationTest, EpochTest) { // Replica1 is not compatible with the main so it shouldn't contain // it's newest vertex { - auto acc = replica1.db.storage()->Access(); + auto acc = replica1.db.Access(); const auto v = acc->FindVertex(*vertex_gid, View::OLD); ASSERT_FALSE(v); ASSERT_FALSE(acc->Commit().HasError()); diff --git a/tests/unit/storage_v2_show_storage_info.cpp b/tests/unit/storage_v2_show_storage_info.cpp index da788978e..2fb750eb8 100644 --- a/tests/unit/storage_v2_show_storage_info.cpp +++ b/tests/unit/storage_v2_show_storage_info.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ class ShowStorageInfoTest : public testing::Test { }; TEST_F(ShowStorageInfoTest, CountOnAbort) { - auto acc = this->storage->Access(); + auto acc = this->storage->Access(memgraph::replication::ReplicationRole::MAIN); auto src_vertex = acc->CreateVertex(); auto dest_vertex = acc->CreateVertex(); auto et = acc->NameToEdgeType("et5"); diff --git a/tests/unit/storage_v2_storage_mode.cpp b/tests/unit/storage_v2_storage_mode.cpp index 49ee633c5..dbf3394d3 100644 --- a/tests/unit/storage_v2_storage_mode.cpp +++ b/tests/unit/storage_v2_storage_mode.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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,8 +44,8 @@ TEST_P(StorageModeTest, Mode) { .transaction{.isolation_level = memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION}}); static_cast(storage.get())->SetStorageMode(storage_mode); - auto creator = storage->Access(); - auto other_analytics_mode_reader = storage->Access(); + auto creator = storage->Access(memgraph::replication::ReplicationRole::MAIN); + auto other_analytics_mode_reader = storage->Access(memgraph::replication::ReplicationRole::MAIN); ASSERT_EQ(CountVertices(*creator, memgraph::storage::View::OLD), 0); ASSERT_EQ(CountVertices(*other_analytics_mode_reader, memgraph::storage::View::OLD), 0); diff --git a/tests/unit/typed_value.cpp b/tests/unit/typed_value.cpp index 5f2f8f3bf..fa2d3cb95 100644 --- a/tests/unit/typed_value.cpp +++ b/tests/unit/typed_value.cpp @@ -1,4 +1,4 @@ -// Copyright 2023 Memgraph Ltd. +// Copyright 2024 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 @@ -37,7 +37,8 @@ class AllTypesFixture : public testing::Test { std::vector values_; memgraph::storage::Config config_{disk_test_utils::GenerateOnDiskConfig(testSuite)}; std::unique_ptr db{new StorageType(config_)}; - std::unique_ptr storage_dba{db->Access()}; + std::unique_ptr storage_dba{ + db->Access(memgraph::replication::ReplicationRole::MAIN)}; memgraph::query::DbAccessor dba{storage_dba.get()}; void SetUp() override {