3604046f68
Make the Interpreter be able to handle SimulatorTransport as well. This includes introducing changes that make it possible to use the different transport types in a semi-polymorphic way with the introduction of factory methods in the RequestRouter. The reason for this solution is that the classes that represent the different transport types have member function templates, that we can not make virtual. This solution seemed to be the least convoluted. In the testing itself now it is possible to pass a set of cypher queried to the interpreter which would run these queries against the interpreter and the individual shards that are managed and started up by the MachineManager with the different entities communicating over the simulated network.
96 lines
3.8 KiB
C++
96 lines
3.8 KiB
C++
// Copyright 2022 Memgraph Ltd.
|
|
//
|
|
// Use of this software is governed by the Business Source License
|
|
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
|
// License, and you may not use this file except in compliance with the Business Source License.
|
|
//
|
|
// As of the Change Date specified in that file, in accordance with
|
|
// the Business Source License, use of this software will be governed
|
|
// by the Apache License, Version 2.0, included in the file
|
|
// licenses/APL.txt.
|
|
|
|
#include <machine_manager/machine_config.hpp>
|
|
#include <machine_manager/machine_manager.hpp>
|
|
#include "io/simulator/simulator_handle.hpp"
|
|
#include "query/v2/config.hpp"
|
|
#include "query/v2/discard_value_stream.hpp"
|
|
#include "query/v2/frontend/ast/ast.hpp"
|
|
#include "query/v2/interpreter.hpp"
|
|
#include "query/v2/request_router.hpp"
|
|
|
|
#include <memory>
|
|
|
|
// TODO(gvolfing)
|
|
// -How to set up the entire raft cluster with the QE. Also provide abrstraction for that.
|
|
// -Pass an argument to the setup to determine, how many times the retry of a query should happen.
|
|
|
|
namespace memgraph::io::simulator {
|
|
|
|
class SimulatedInterpreter {
|
|
using ResultStream = query::v2::DiscardValueResultStream;
|
|
|
|
public:
|
|
explicit SimulatedInterpreter(std::unique_ptr<query::v2::InterpreterContext> &&interpreter_context)
|
|
: interpreter_context_(std::move(interpreter_context)) {
|
|
interpreter_ = std::make_unique<memgraph::query::v2::Interpreter>(&(*interpreter_context_));
|
|
}
|
|
|
|
SimulatedInterpreter(const SimulatedInterpreter &) = delete;
|
|
SimulatedInterpreter &operator=(const SimulatedInterpreter &) = delete;
|
|
SimulatedInterpreter(SimulatedInterpreter &&) = delete;
|
|
SimulatedInterpreter &operator=(SimulatedInterpreter &&) = delete;
|
|
~SimulatedInterpreter() = default;
|
|
|
|
std::vector<ResultStream> RunQueries(const std::vector<std::string> &queries) {
|
|
std::vector<ResultStream> results;
|
|
results.reserve(queries.size());
|
|
|
|
for (const auto &query : queries) {
|
|
results.emplace_back(RunQuery(query));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private:
|
|
ResultStream RunQuery(const std::string &query) {
|
|
ResultStream stream;
|
|
|
|
std::map<std::string, memgraph::storage::v3::PropertyValue> params;
|
|
const std::string *username = nullptr;
|
|
|
|
interpreter_->BeginTransaction();
|
|
|
|
auto *rr = interpreter_->GetRequestRouter();
|
|
rr->StartTransaction();
|
|
|
|
interpreter_->Prepare(query, params, username);
|
|
interpreter_->PullAll(&stream);
|
|
interpreter_->CommitTransaction();
|
|
|
|
return stream;
|
|
}
|
|
|
|
std::unique_ptr<query::v2::InterpreterContext> interpreter_context_;
|
|
std::unique_ptr<query::v2::Interpreter> interpreter_;
|
|
};
|
|
|
|
SimulatedInterpreter SetUpInterpreter(Address coordinator_address, Simulator &simulator) {
|
|
auto rr_factory =
|
|
std::make_unique<memgraph::query::v2::SimulatedRequestRouterFactory>(simulator, coordinator_address);
|
|
|
|
auto interpreter_context = std::make_unique<memgraph::query::v2::InterpreterContext>(
|
|
(memgraph::storage::v3::Shard *)(nullptr),
|
|
memgraph::query::v2::InterpreterConfig{.query = {.allow_load_csv = true},
|
|
.execution_timeout_sec = 600,
|
|
.replication_replica_check_frequency = std::chrono::seconds(1),
|
|
.default_kafka_bootstrap_servers = "",
|
|
.default_pulsar_service_url = "",
|
|
.stream_transaction_conflict_retries = 30,
|
|
.stream_transaction_retry_interval = std::chrono::milliseconds(500)},
|
|
std::filesystem::path("mg_data"), std::move(rr_factory), coordinator_address);
|
|
|
|
return SimulatedInterpreter(std::move(interpreter_context));
|
|
}
|
|
|
|
} // namespace memgraph::io::simulator
|