void Optimizer::generateQueryHandle(const ParseStatement &parse_statement,
QueryHandle *query_handle) {
LogicalGenerator logical_generator(&optimizer_context_);
PhysicalGenerator physical_generator;
ExecutionGenerator execution_generator(&optimizer_context_, query_handle);
execution_generator.generatePlan(
physical_generator.generatePlan(
logical_generator.generatePlan(parse_statement)));
}
void CommandExecutorTestRunner::runTestCase(
const std::string &input, const std::set<std::string> &options,
std::string *output) {
// TODO(qzeng): Test multi-threaded query execution when we have a Sort operator.
VLOG(4) << "Test SQL(s): " << input;
if (options.find(kResetOption) != options.end()) {
test_database_loader_.clear();
test_database_loader_.createTestRelation(false /* allow_vchar */);
test_database_loader_.loadTestRelation();
}
MemStream output_stream;
sql_parser_.feedNextBuffer(new std::string(input));
while (true) {
ParseResult result = sql_parser_.getNextStatement();
O::OptimizerContext optimizer_context(0 /* query_id */,
test_database_loader_.catalog_database(),
test_database_loader_.storage_manager());
if (result.condition != ParseResult::kSuccess) {
if (result.condition == ParseResult::kError) {
*output = result.error_message;
}
break;
} else {
std::printf("%s\n", result.parsed_statement->toString().c_str());
try {
if (result.parsed_statement->getStatementType() == ParseStatement::kCommand) {
quickstep::cli::executeCommand(
*result.parsed_statement,
*(test_database_loader_.catalog_database()),
main_thread_client_id_,
foreman_->getBusClientID(),
&bus_,
test_database_loader_.storage_manager(),
nullptr,
output_stream.file());
} else {
QueryHandle query_handle(optimizer_context.query_id());
O::LogicalGenerator logical_generator(&optimizer_context);
O::PhysicalGenerator physical_generator;
O::ExecutionGenerator execution_generator(&optimizer_context, &query_handle);
const P::PhysicalPtr physical_plan =
physical_generator.generatePlan(
logical_generator.generatePlan(*result.parsed_statement));
execution_generator.generatePlan(physical_plan);
AdmitRequestMessage request_message(&query_handle);
TaggedMessage admit_tagged_message(
&request_message, sizeof(request_message), kAdmitRequestMessage);
QueryExecutionUtil::SendTMBMessage(&bus_,
main_thread_client_id_,
foreman_->getBusClientID(),
std::move(admit_tagged_message));
// Receive workload completion message from Foreman.
const AnnotatedMessage annotated_msg =
bus_.Receive(main_thread_client_id_, 0, true);
const TaggedMessage &tagged_message = annotated_msg.tagged_message;
DCHECK_EQ(kWorkloadCompletionMessage, tagged_message.message_type());
const CatalogRelation *query_result_relation = query_handle.getQueryResultRelation();
if (query_result_relation) {
PrintToScreen::PrintRelation(*query_result_relation,
test_database_loader_.storage_manager(),
output_stream.file());
DropRelation::Drop(*query_result_relation,
test_database_loader_.catalog_database(),
test_database_loader_.storage_manager());
}
}
} catch (const SqlError &error) {
*output = error.formatMessage(input);
break;
}
}
}
if (output->empty()) {
*output = output_stream.str();
}
}
logical::LogicalPtr OptimizerTextTestRunner::generateLogicalPlan(
const ParseStatement &parse_statement,
OptimizerContext *optimizer_context) {
LogicalGenerator logical_generator(optimizer_context);
return logical_generator.generatePlan(parse_statement);
}
void ExecutionGeneratorTestRunner::runTestCase(
const std::string &input, const std::set<std::string> &options,
std::string *output) {
// TODO(qzeng): Test multi-threaded query execution when we have a Sort operator.
VLOG(4) << "Test SQL(s): " << input;
if (options.find(kResetOption) != options.end()) {
test_database_loader_.clear();
test_database_loader_.createTestRelation(false /* allow_vchar */);
test_database_loader_.loadTestRelation();
}
MemStream output_stream;
sql_parser_.feedNextBuffer(new std::string(input));
while (true) {
ParseResult result = sql_parser_.getNextStatement();
OptimizerContext optimizer_context(0 /* query_id */,
test_database_loader_.catalog_database(),
test_database_loader_.storage_manager());
if (result.condition != ParseResult::kSuccess) {
if (result.condition == ParseResult::kError) {
*output = result.error_message;
}
break;
} else {
std::printf("%s\n", result.parsed_statement->toString().c_str());
try {
QueryHandle query_handle(optimizer_context.query_id());
LogicalGenerator logical_generator(&optimizer_context);
PhysicalGenerator physical_generator;
ExecutionGenerator execution_generator(&optimizer_context,
&query_handle);
const physical::PhysicalPtr physical_plan =
physical_generator.generatePlan(
logical_generator.generatePlan(*result.parsed_statement));
execution_generator.generatePlan(physical_plan);
foreman_->setQueryPlan(
query_handle.getQueryPlanMutable()->getQueryPlanDAGMutable());
foreman_->reconstructQueryContextFromProto(query_handle.getQueryContextProto());
foreman_->start();
foreman_->join();
const CatalogRelation *query_result_relation = query_handle.getQueryResultRelation();
if (query_result_relation) {
PrintToScreen::PrintRelation(*query_result_relation,
test_database_loader_.storage_manager(),
output_stream.file());
DropRelation::Drop(*query_result_relation,
test_database_loader_.catalog_database(),
test_database_loader_.storage_manager());
}
} catch (const SqlError &error) {
*output = error.formatMessage(input);
break;
}
}
}
if (output->empty()) {
*output = output_stream.str();
}
}
