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

Fix schema visitor

Browse Source
This commit is contained in:
jbajic 2022-06-13 14:00:39 +02:00
parent c95c428355
commit eebb48d094
3 changed files with 58 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/query/frontend/ast/cypher_main_visitor.cpp
View File

@ -2340,6 +2340,7 @@ antlrcpp::Any CypherMainVisitor::visitForeach(MemgraphCypher::ForeachContext *ct
antlrcpp::Any CypherMainVisitor::visitSchemaQuery(MemgraphCypher::SchemaQueryContext *ctx) {
MG_ASSERT(ctx->children.size() == 1, "SchemaQuery should have exactly one child!");
auto *schema_query = ctx->children[0]->accept(this).as<SchemaQuery *>();
query_ = schema_query;
return schema_query;
}
@ -2347,12 +2348,14 @@ antlrcpp::Any CypherMainVisitor::visitShowSchema(MemgraphCypher::ShowSchemaConte
auto *schema_query = storage_->Create<SchemaQuery>();
schema_query->action_ = SchemaQuery::Action::SHOW_SCHEMA;
schema_query->label_ = AddLabel(ctx->labelName()->accept(this));
query_ = schema_query;
return schema_query;
}
antlrcpp::Any CypherMainVisitor::visitShowSchemas(MemgraphCypher::ShowSchemasContext *ctx) {
auto *schema_query = storage_->Create<SchemaQuery>();
schema_query->action_ = SchemaQuery::Action::SHOW_SCHEMAS;
query_ = schema_query;
return schema_query;
}
@ -2371,6 +2374,7 @@ antlrcpp::Any CypherMainVisitor::visitCreateSchema(MemgraphCypher::CreateSchemaC
antlrcpp::Any CypherMainVisitor::visitDropSchema(MemgraphCypher::DropSchemaContext *ctx) {
auto *schema_query = storage_->Create<SchemaQuery>();
schema_query->action_ = SchemaQuery::Action::DROP_SCHEMA;
query_ = schema_query;
return schema_query;
}

1
src/query/frontend/opencypher/grammar/MemgraphCypher.g4
View File

@ -198,6 +198,7 @@ settingQuery : setSetting
schemaQuery : showSchema
| showSchemas
| createSchema
| dropSchema
;
loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER

94
src/query/interpreter.cpp
View File

@ -823,7 +823,7 @@ Callback HandleSettingQuery(SettingQuery *setting_query, const Parameters &param
Callback HandleSchemaQuery(SchemaQuery *schema_query, const Parameters &parameters,
InterpreterContext *interpreter_context, DbAccessor *db_accessor,
const std::string *username, std::vector<Notification> *notifications) {
std::vector<Notification> *notifications) {
Frame frame(0);
SymbolTable symbol_table;
EvaluationContext evaluation_context;
@ -871,28 +871,48 @@ Callback HandleSchemaQuery(SchemaQuery *schema_query, const Parameters &paramete
auto *db = interpreter_context->db;
const auto label = db->NameToLabel(schema_query->label_.name);
const auto schemas_info = db->GetSchema(label);
MG_ASSERT(schemas_info.schemas.size() == 1, "There can be only one schema under single label!");
const auto schema = schemas_info.schemas[0];
MG_ASSERT(schemas_info.schemas.size() < 2, "There can be only one schema under single label!");
std::vector<std::vector<TypedValue>> results;
if (!schemas_info.schemas.empty()) {
const auto schema = schemas_info.schemas[0];
for (const auto &schema_property : schema.second) {
std::vector<TypedValue> schema_info_row;
schema_info_row.reserve(2);
for (const auto &schema_property : schema.second) {
std::vector<TypedValue> schema_info_row;
schema_info_row.reserve(2);
schema_info_row.emplace_back(db->PropertyToName(schema_property.property_id));
schema_info_row.emplace_back(SchemaPropertyToString(schema_property.type));
schema_info_row.emplace_back(db->PropertyToName(schema_property.property_id));
schema_info_row.emplace_back(SchemaPropertyToString(schema_property.type));
results.push_back(std::move(schema_info_row));
results.push_back(std::move(schema_info_row));
}
}
return results;
};
return callback;
}
case SchemaQuery::Action::CREATE_SCHEMA: {
break;
callback.fn = [interpreter_context, schema_query]() {
auto *db = interpreter_context->db;
const auto label = db->NameToLabel(schema_query->label_.name);
std::vector<storage::SchemaProperty> schemas_types;
for (const auto &schema_property : schema_query->properties_type_map_) {
spdlog::info("sasa {}", db->PropertyToName(db->NameToProperty(schema_property.first.name)));
// schemas_types.emplace_back(db->NameToProperty(schema_property.first.name), schema_property.second);
}
const auto res = db->CreateSchema(label, schemas_types);
return std::vector<std::vector<TypedValue>>{};
};
return callback;
}
case SchemaQuery::Action::DROP_SCHEMA: {
break;
callback.fn = [interpreter_context, schema_query]() {
auto *db = interpreter_context->db;
const auto label = db->NameToLabel(schema_query->label_.name);
const auto res = db->DeleteSchema(label);
return std::vector<std::vector<TypedValue>>{};
};
return callback;
}
}
return callback;
@ -2094,42 +2114,34 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
}
PreparedQuery PrepareSchemaQuery(ParsedQuery parsed_query, bool in_explicit_transaction,
InterpreterContext *interpreter_context, std::vector<Notification> *notifications) {
InterpreterContext *interpreter_context, DbAccessor *dba,
std::vector<Notification> *notifications) {
if (in_explicit_transaction) {
throw ConstraintInMulticommandTxException();
}
auto *schema_query = utils::Downcast<SchemaQuery>(parsed_query.query);
spdlog::info("Prepare Schema query!");
MG_ASSERT(schema_query);
auto callback = HandleSchemaQuery(schema_query, parsed_query.parameters, interpreter_context, dba, notifications);
Notification schema_notification(SeverityLevel::INFO);
switch (schema_query->action_) {
case SchemaQuery::Action::CREATE_SCHEMA: {
schema_notification.code = NotificationCode::CREATE_SCHEMA;
spdlog::info("Prepare Create Schema query!");
break;
}
case SchemaQuery::Action::DROP_SCHEMA: {
schema_notification.code = NotificationCode::DROP_SCHEMA;
spdlog::info("Prepare Drop Schema query!");
break;
}
case SchemaQuery::Action::SHOW_SCHEMA: {
schema_notification.code = NotificationCode::SHOW_SCHEMA;
spdlog::info("Prepare show Schema query!");
break;
}
case SchemaQuery::Action::SHOW_SCHEMAS: {
schema_notification.code = NotificationCode::SHOW_SCHEMAS;
spdlog::info("Prepare show schemas query!");
break;
}
}
// return PreparedQuery{std::move(callback.header), std::move(parsed_query.required_privileges),
// [handler = std::move(callback.fn), action = QueryHandlerResult::NOTHING,
// pull_plan = std::shared_ptr<PullPlanVector>(nullptr)](
// AnyStream *stream, std::optional<int> n) mutable -> std::optional<QueryHandlerResult> {
// if (!pull_plan) {
// auto results = handler();
// pull_plan = std::make_shared<PullPlanVector>(std::move(results));
// }
return PreparedQuery{{},
// if (pull_plan->Pull(stream, n)) {
// return action;
// }
// return std::nullopt;
// },
// RWType::NONE};
return PreparedQuery{{std::move(callback.header)},
std::move(parsed_query.required_privileges),
[schema_notification = std::move(schema_notification), notifications](AnyStream * /*stream*/,
std::optional<int> /*n*/) {
notifications->push_back(schema_notification);
[handler = std::move(callback.fn)](AnyStream * /*stream*/, std::optional<int> /*n*/) mutable {
handler();
return QueryHandlerResult::COMMIT;
},
RWType::NONE};
@ -2270,7 +2282,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
prepared_query = PrepareVersionQuery(std::move(parsed_query), in_explicit_transaction_);
} else if (utils::Downcast<SchemaQuery>(parsed_query.query)) {
prepared_query = PrepareSchemaQuery(std::move(parsed_query), in_explicit_transaction_, interpreter_context_,
&query_execution->notifications);
&*execution_db_accessor_, &query_execution->notifications);
} else {
LOG_FATAL("Should not get here -- unknown query type!");
}