eb821aa615
Summary: AST caching should be well tested by now. We should consider removing `Context.is_query_cached_` member as well as the implementation and tests for `CypherMainVisitor`. Reviewers: mislav.bradac, mferencevic, buda Reviewed By: mislav.bradac Subscribers: pullbot Differential Revision: https://phabricator.memgraph.io/D833
85 lines
3.1 KiB
C++
85 lines
3.1 KiB
C++
#include "query/interpreter.hpp"
|
|
|
|
#include "query/plan/cost_estimator.hpp"
|
|
#include "query/plan/planner.hpp"
|
|
#include "query/plan/vertex_count_cache.hpp"
|
|
#include "utils/flag_validation.hpp"
|
|
|
|
DEFINE_bool(query_cost_planner, true,
|
|
"Use the cost-estimating query planner.");
|
|
DEFINE_bool(query_plan_cache, true, "Cache generated query plans");
|
|
DEFINE_VALIDATED_int32(query_plan_cache_ttl, 60,
|
|
"Time to live for cached query plans, in seconds.",
|
|
FLAG_IN_RANGE(0, std::numeric_limits<int32_t>::max()));
|
|
|
|
namespace query {
|
|
|
|
AstTreeStorage Interpreter::QueryToAst(const StrippedQuery &stripped,
|
|
Context &ctx) {
|
|
if (!ctx.is_query_cached_) {
|
|
// stripped query -> AST
|
|
auto parser = [&] {
|
|
// Be careful about unlocking since parser can throw.
|
|
std::unique_lock<SpinLock> guard(antlr_lock_);
|
|
return std::make_unique<frontend::opencypher::Parser>(
|
|
stripped.original_query());
|
|
}();
|
|
auto low_level_tree = parser->tree();
|
|
// AST -> high level tree
|
|
frontend::CypherMainVisitor visitor(ctx);
|
|
visitor.visit(low_level_tree);
|
|
return std::move(visitor.storage());
|
|
}
|
|
auto ast_cache_accessor = ast_cache_.access();
|
|
auto ast_it = ast_cache_accessor.find(stripped.hash());
|
|
if (ast_it == ast_cache_accessor.end()) {
|
|
// stripped query -> AST
|
|
auto parser = [&] {
|
|
// Be careful about unlocking since parser can throw.
|
|
std::unique_lock<SpinLock> guard(antlr_lock_);
|
|
return std::make_unique<frontend::opencypher::Parser>(stripped.query());
|
|
}();
|
|
auto low_level_tree = parser->tree();
|
|
// AST -> high level tree
|
|
frontend::CypherMainVisitor visitor(ctx);
|
|
visitor.visit(low_level_tree);
|
|
// Cache it.
|
|
ast_it =
|
|
ast_cache_accessor.insert(stripped.hash(), std::move(visitor.storage()))
|
|
.first;
|
|
}
|
|
AstTreeStorage new_ast;
|
|
ast_it->second.query()->Clone(new_ast);
|
|
return new_ast;
|
|
}
|
|
|
|
std::pair<std::unique_ptr<plan::LogicalOperator>, double>
|
|
Interpreter::MakeLogicalPlan(AstTreeStorage &ast_storage,
|
|
const GraphDbAccessor &db_accessor,
|
|
Context &context) {
|
|
std::unique_ptr<plan::LogicalOperator> logical_plan;
|
|
double min_cost = std::numeric_limits<double>::max();
|
|
auto vertex_counts = plan::MakeVertexCountCache(db_accessor);
|
|
if (FLAGS_query_cost_planner) {
|
|
auto plans = plan::MakeLogicalPlan<plan::VariableStartPlanner>(
|
|
ast_storage, context.symbol_table_, vertex_counts);
|
|
for (auto &plan : plans) {
|
|
auto cost = EstimatePlanCost(vertex_counts, context.parameters_, *plan);
|
|
if (!logical_plan || cost < min_cost) {
|
|
// We won't be iterating over plans anymore, so it's ok to invalidate
|
|
// unique_ptrs inside.
|
|
logical_plan = std::move(plan);
|
|
min_cost = cost;
|
|
}
|
|
}
|
|
} else {
|
|
logical_plan = plan::MakeLogicalPlan<plan::RuleBasedPlanner>(
|
|
ast_storage, context.symbol_table_, vertex_counts);
|
|
min_cost =
|
|
EstimatePlanCost(vertex_counts, context.parameters_, *logical_plan);
|
|
}
|
|
return {std::move(logical_plan), min_cost};
|
|
};
|
|
|
|
} // namespace query
|