tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'MG-pmr-property-value' into MG-pmr-property-value-fixed

Browse Source
This commit is contained in:
Antonio Andelic 2022-02-11 12:43:29 +01:00
commit c8769fa677
7 changed files with 86 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tests/benchmark/expansion.cpp
View File

@ -16,7 +16,9 @@
#include "query/interpreter.hpp"
#include "query/typed_value.hpp"
#include "storage/v2/isolation_level.hpp"
#include "storage/v2/property_value.hpp"
#include "storage/v2/storage.hpp"
#include "utils/memory.hpp"
class ExpansionBenchFixture : public benchmark::Fixture {
protected:
@ -64,7 +66,7 @@ BENCHMARK_DEFINE_F(ExpansionBenchFixture, Match)(benchmark::State &state) {
while (state.KeepRunning()) {
ResultStreamFaker results(&*db);
interpreter->Prepare(query, {}, nullptr);
interpreter->Prepare(query, storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
interpreter->PullAll(&results);
}
}
@ -79,7 +81,7 @@ BENCHMARK_DEFINE_F(ExpansionBenchFixture, Expand)(benchmark::State &state) {
while (state.KeepRunning()) {
ResultStreamFaker results(&*db);
interpreter->Prepare(query, {}, nullptr);
interpreter->Prepare(query, storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
interpreter->PullAll(&results);
}
}

4
tests/manual/single_query.cpp
View File

@ -15,6 +15,7 @@
#include "storage/v2/isolation_level.hpp"
#include "storage/v2/storage.hpp"
#include "utils/license.hpp"
#include "utils/memory.hpp"
#include "utils/on_scope_exit.hpp"
int main(int argc, char *argv[]) {
@ -35,7 +36,8 @@ int main(int argc, char *argv[]) {
query::Interpreter interpreter{&interpreter_context};
ResultStreamFaker stream(&db);
auto [header, _, qid] = interpreter.Prepare(argv[1], {}, nullptr);
auto [header, _, qid] =
interpreter.Prepare(argv[1], storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
stream.Header(header);
auto summary = interpreter.PullAll(&stream);
stream.Summary(summary);

11
tests/unit/interpreter.cpp
View File

@ -29,6 +29,7 @@
#include "storage/v2/property_value.hpp"
#include "utils/csv_parsing.hpp"
#include "utils/logging.hpp"
#include "utils/memory.hpp"
namespace {
@ -40,6 +41,14 @@ auto ToEdgeList(const communication::bolt::Value &v) {
return list;
};
auto ToPropertyValueMap(const std::map<std::string, storage::PropertyValue> &map) {
storage::PropertyValue::TMap property_value_map{utils::NewDeleteResource()};
for (const auto &[key, value] : map) {
property_value_map.emplace(utils::pmr::string{key, utils::NewDeleteResource()}, std::move(value));
}
return property_value_map;
}
struct InterpreterFaker {
InterpreterFaker(storage::Storage *db, const query::InterpreterConfig config,
const std::filesystem::path &data_directory)
@ -50,7 +59,7 @@ struct InterpreterFaker {
auto Prepare(const std::string &query, const std::map<std::string, storage::PropertyValue> &params = {}) {
ResultStreamFaker stream(interpreter_context.db);
const auto [header, _, qid] = interpreter.Prepare(query, params, nullptr);
const auto [header, _, qid] = interpreter.Prepare(query, ToPropertyValueMap(params), nullptr);
stream.Header(header);
return std::make_pair(std::move(stream), qid);
}

9
tests/unit/property_value_v2.cpp
View File

@ -15,6 +15,7 @@
#include "storage/v2/property_value.hpp"
#include "storage/v2/temporal.hpp"
#include "utils/memory.hpp"
// NOLINTNEXTLINE(hicpp-special-member-functions)
TEST(PropertyValue, Null) {
@ -423,7 +424,7 @@ TEST(PropertyValue, MapCopy) {
{
const auto &ret = pv.ValueMap();
ASSERT_EQ(ret.size(), 1);
ASSERT_EQ(ret.at("nandare").ValueInt(), 123);
ASSERT_EQ(ret.at({"nandare", utils::NewDeleteResource()}).ValueInt(), 123);
}
const auto &cpv = pv;
@ -436,7 +437,7 @@ TEST(PropertyValue, MapCopy) {
{
const auto &ret = cpv.ValueMap();
ASSERT_EQ(ret.size(), 1);
ASSERT_EQ(ret.at("nandare").ValueInt(), 123);
ASSERT_EQ(ret.at({"nandare", utils::NewDeleteResource()}).ValueInt(), 123);
}
{
@ -476,7 +477,7 @@ TEST(PropertyValue, MapMove) {
{
const auto &ret = pv.ValueMap();
ASSERT_EQ(ret.size(), 1);
ASSERT_EQ(ret.at("nandare").ValueInt(), 123);
ASSERT_EQ(ret.at({"nandare", utils::NewDeleteResource()}).ValueInt(), 123);
}
const auto &cpv = pv;
@ -489,7 +490,7 @@ TEST(PropertyValue, MapMove) {
{
const auto &ret = cpv.ValueMap();
ASSERT_EQ(ret.size(), 1);
ASSERT_EQ(ret.at("nandare").ValueInt(), 123);
ASSERT_EQ(ret.at({"nandare", utils::NewDeleteResource()}).ValueInt(), 123);
}
{

17
tests/unit/query_dump.cpp
View File

@ -21,8 +21,10 @@
#include "query/dump.hpp"
#include "query/interpreter.hpp"
#include "query/typed_value.hpp"
#include "storage/v2/property_value.hpp"
#include "storage/v2/storage.hpp"
#include "storage/v2/temporal.hpp"
#include "utils/memory.hpp"
#include "utils/temporal.hpp"
const char *kPropertyId = "property_id";
@ -207,7 +209,7 @@ auto Execute(storage::Storage *db, const std::string &query) {
query::Interpreter interpreter(&context);
ResultStreamFaker stream(db);
auto [header, _, qid] = interpreter.Prepare(query, {}, nullptr);
auto [header, _, qid] = interpreter.Prepare(query, storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
stream.Header(header);
auto summary = interpreter.PullAll(&stream);
stream.Summary(summary);
@ -399,7 +401,12 @@ TEST(DumpTest, PropertyValue) {
auto bool_value = storage::PropertyValue(true);
auto double_value = storage::PropertyValue(-1.2);
auto str_value = storage::PropertyValue("hello 'world'");
auto map_value = storage::PropertyValue({{"prop 1", int_value}, {"prop`2`", bool_value}});
storage::PropertyValue map_value = storage::PropertyValue(std::invoke([&] {
storage::PropertyValue::TMap map_value{utils::NewDeleteResource()};
map_value.emplace(storage::PropertyValue::TString{"prop 1", utils::NewDeleteResource()}, int_value);
map_value.emplace(storage::PropertyValue::TString{"prop 2", utils::NewDeleteResource()}, bool_value);
return map_value;
}));
auto dt = storage::PropertyValue(
storage::TemporalData(storage::TemporalType::Date, utils::Date({1994, 12, 7}).MicrosecondsSinceEpoch()));
auto lt = storage::PropertyValue(storage::TemporalData(
@ -409,7 +416,8 @@ TEST(DumpTest, PropertyValue) {
utils::LocalDateTime({1994, 12, 7}, {14, 10, 44, 99, 99}).MicrosecondsSinceEpoch()));
auto dur = storage::PropertyValue(
storage::TemporalData(storage::TemporalType::Duration, utils::Duration({3, 4, 5, 6, 10, 11}).microseconds));
auto list_value = storage::PropertyValue({map_value, null_value, double_value, dt, lt, ldt, dur});
auto list_value = storage::PropertyValue(storage::PropertyValue::TVector{
{map_value, null_value, double_value, dt, lt, ldt, dur}, utils::NewDeleteResource()});
CreateVertex(&dba, {}, {{"p1", list_value}, {"p2", str_value}}, false);
ASSERT_FALSE(dba.Commit().HasError());
}
@ -751,7 +759,8 @@ class StatefulInterpreter {
auto Execute(const std::string &query) {
ResultStreamFaker stream(db_);
auto [header, _, qid] = interpreter_.Prepare(query, {}, nullptr);
auto [header, _, qid] =
interpreter_.Prepare(query, storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
stream.Header(header);
auto summary = interpreter_.PullAll(&stream);
stream.Summary(summary);

4
tests/unit/query_plan_edge_cases.cpp
View File

@ -22,6 +22,7 @@
#include "communication/result_stream_faker.hpp"
#include "query/interpreter.hpp"
#include "storage/v2/storage.hpp"
#include "utils/memory.hpp"
DECLARE_bool(query_cost_planner);
@ -53,7 +54,8 @@ class QueryExecution : public testing::Test {
auto Execute(const std::string &query) {
ResultStreamFaker stream(&*db_);
auto [header, _, qid] = interpreter_->Prepare(query, {}, nullptr);
auto [header, _, qid] =
interpreter_->Prepare(query, storage::PropertyValue::TMap{utils::NewDeleteResource()}, nullptr);
stream.Header(header);
auto summary = interpreter_->PullAll(&stream);
stream.Summary(summary);

85
tests/unit/query_trigger.cpp
View File

@ -877,11 +877,15 @@ TEST_F(TriggerStoreTest, Restore) {
const auto event_type = query::TriggerEventType::VERTEX_CREATE;
const std::string owner{"owner"};
store->AddTrigger(trigger_name_before, trigger_statement,
std::map<std::string, storage::PropertyValue>{{"parameter", storage::PropertyValue{1}}}, event_type,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
storage::PropertyValue::TMap{
{{utils::pmr::string{"parameter", utils::NewDeleteResource()}, storage::PropertyValue{1}}},
utils::NewDeleteResource()},
event_type, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
store->AddTrigger(trigger_name_after, trigger_statement,
std::map<std::string, storage::PropertyValue>{{"parameter", storage::PropertyValue{"value"}}},
storage::PropertyValue::TMap{
{{utils::pmr::string{"parameter", utils::NewDeleteResource()}, storage::PropertyValue{1}}},
utils::NewDeleteResource()},
event_type, query::TriggerPhase::AFTER_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, {owner}, &auth_checker);
@ -932,34 +936,38 @@ TEST_F(TriggerStoreTest, AddTrigger) {
query::TriggerStore store{testing_directory};
// Invalid query in statements
ASSERT_THROW(store.AddTrigger("trigger", "RETUR 1", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_THROW(store.AddTrigger("trigger", "RETURN createdEdges", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
ASSERT_THROW(store.AddTrigger("trigger", "RETUR 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_THROW(
store.AddTrigger("trigger", "RETURN createdEdges", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_THROW(store.AddTrigger("trigger", "RETURN $parameter", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_THROW(
store.AddTrigger("trigger", "RETURN $parameter", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_NO_THROW(
store.AddTrigger("trigger", "RETURN $parameter",
std::map<std::string, storage::PropertyValue>{{"parameter", storage::PropertyValue{1}}},
storage::PropertyValue::TMap{
{{utils::pmr::string{"parameter", utils::NewDeleteResource()}, storage::PropertyValue{1}}},
utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker));
// Inserting with the same name
ASSERT_THROW(store.AddTrigger("trigger", "RETURN 1", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
ASSERT_THROW(store.AddTrigger("trigger", "RETURN 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_THROW(store.AddTrigger("trigger", "RETURN 1", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::AFTER_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
ASSERT_THROW(store.AddTrigger("trigger", "RETURN 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker),
utils::BasicException);
ASSERT_EQ(store.GetTriggerInfo().size(), 1);
@ -973,9 +981,9 @@ TEST_F(TriggerStoreTest, DropTrigger) {
ASSERT_THROW(store.DropTrigger("Unknown"), utils::BasicException);
const auto *trigger_name = "trigger";
store.AddTrigger(trigger_name, "RETURN 1", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
store.AddTrigger(trigger_name, "RETURN 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
ASSERT_THROW(store.DropTrigger("Unknown"), utils::BasicException);
ASSERT_NO_THROW(store.DropTrigger(trigger_name));
@ -986,9 +994,9 @@ TEST_F(TriggerStoreTest, TriggerInfo) {
query::TriggerStore store{testing_directory};
std::vector<query::TriggerStore::TriggerInfo> expected_info;
store.AddTrigger("trigger", "RETURN 1", {}, query::TriggerEventType::VERTEX_CREATE,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
store.AddTrigger("trigger", "RETURN 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
expected_info.push_back(
{"trigger", "RETURN 1", query::TriggerEventType::VERTEX_CREATE, query::TriggerPhase::BEFORE_COMMIT});
@ -1006,9 +1014,9 @@ TEST_F(TriggerStoreTest, TriggerInfo) {
check_trigger_info();
store.AddTrigger("edge_update_trigger", "RETURN 1", {}, query::TriggerEventType::EDGE_UPDATE,
query::TriggerPhase::AFTER_COMMIT, &ast_cache, &*dba, &antlr_lock, query::InterpreterConfig::Query{},
std::nullopt, &auth_checker);
store.AddTrigger("edge_update_trigger", "RETURN 1", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache, &*dba,
&antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &auth_checker);
expected_info.push_back(
{"edge_update_trigger", "RETURN 1", query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT});
@ -1119,7 +1127,8 @@ TEST_F(TriggerStoreTest, AnyTriggerAllKeywords) {
SCOPED_TRACE(query::TriggerEventTypeToString(event_type));
for (const auto keyword : keywords) {
SCOPED_TRACE(keyword);
EXPECT_NO_THROW(store.AddTrigger(trigger_name, fmt::format("RETURN {}", keyword), {}, event_type,
EXPECT_NO_THROW(store.AddTrigger(trigger_name, fmt::format("RETURN {}", keyword),
storage::PropertyValue::TMap{utils::NewDeleteResource()}, event_type,
query::TriggerPhase::BEFORE_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &auth_checker));
store.DropTrigger(trigger_name);
@ -1143,12 +1152,13 @@ TEST_F(TriggerStoreTest, AuthCheckerUsage) {
.WillOnce(Return(true));
EXPECT_CALL(mock_checker, IsUserAuthorized(owner, ElementsAre(Privilege::CREATE))).Times(1).WillOnce(Return(true));
ASSERT_NO_THROW(store->AddTrigger("successfull_trigger_1", "CREATE (n:VERTEX) RETURN n", {},
query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, std::nullopt,
&mock_checker));
ASSERT_NO_THROW(store->AddTrigger(
"successfull_trigger_1", "CREATE (n:VERTEX) RETURN n", storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache, &*dba, &antlr_lock,
query::InterpreterConfig::Query{}, std::nullopt, &mock_checker));
ASSERT_NO_THROW(store->AddTrigger("successfull_trigger_2", "CREATE (n:VERTEX) RETURN n", {},
ASSERT_NO_THROW(store->AddTrigger("successfull_trigger_2", "CREATE (n:VERTEX) RETURN n",
storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, owner, &mock_checker));
@ -1156,7 +1166,8 @@ TEST_F(TriggerStoreTest, AuthCheckerUsage) {
.Times(1)
.WillOnce(Return(false));
ASSERT_THROW(store->AddTrigger("unprivileged_trigger", "MATCH (n:VERTEX) RETURN n", {},
ASSERT_THROW(store->AddTrigger("unprivileged_trigger", "MATCH (n:VERTEX) RETURN n",
storage::PropertyValue::TMap{utils::NewDeleteResource()},
query::TriggerEventType::EDGE_UPDATE, query::TriggerPhase::AFTER_COMMIT, &ast_cache,
&*dba, &antlr_lock, query::InterpreterConfig::Query{}, std::nullopt, &mock_checker);
, utils::BasicException);