Method execute

src/Interpreters/InterpreterAdviseQuery.cpp:32–122

}

BlockIO InterpreterAdviseQuery::execute()
{
    Block advise_result{
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "database"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "table"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "column"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "advise_type"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "original"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "optimized"},
        ColumnWithTypeAndName{std::make_shared<DataTypeString>(), "status"}};
    Block optimized_ddls_result = advise_result.cloneEmpty();
    auto advise_result_columns = advise_result.mutateColumns();
    auto optimized_ddls_columns = optimized_ddls_result.mutateColumns();

    std::vector<String> queries = loadQueries();
    WorkloadTables tables = loadTables();

    auto start_watch = std::chrono::high_resolution_clock::now();
    Advisor advisor(query_ptr->as<const ASTAdviseQuery &>().type);
    auto advises = advisor.analyze(queries, getContext());
    auto stop_watch = std::chrono::high_resolution_clock::now();

    LOG_DEBUG(&Poco::Logger::get("InterpreterAdviseQuery"), "Analyze cost: {} ms",
              std::chrono::duration_cast<std::chrono::milliseconds>(stop_watch - start_watch).count());

    start_watch = std::chrono::high_resolution_clock::now();

    for (auto & advise : advises)
    {
        String result = advise->apply(tables);

        advise_result_columns[0]->insert(advise->getTable().database);
        advise_result_columns[1]->insert(advise->getTable().table);
        advise_result_columns[2]->insert(advise->getColumnName().value_or(""));
        advise_result_columns[3]->insert(advise->getAdviseType());
        advise_result_columns[4]->insert(advise->getOriginalValue());
        advise_result_columns[5]->insert(advise->getOptimizedValue());
        advise_result_columns[6]->insert(result);
    }

    stop_watch = std::chrono::high_resolution_clock::now();

    LOG_DEBUG(&Poco::Logger::get("InterpreterAdviseQuery"), "Apply advises cost: {} ms",
              std::chrono::duration_cast<std::chrono::milliseconds>(stop_watch - start_watch).count());

    if (query_ptr->as<const ASTAdviseQuery &>().output_ddl)
    {
        start_watch = std::chrono::high_resolution_clock::now();

        std::vector<std::pair<QualifiedTableName, String>> optimized_ddls = tables.getOptimizedDDLs();

        auto optimized_file = query_ptr->as<const ASTAdviseQuery &>().optimized_file;
        if (optimized_file)
        {
            std::vector<String> ddls;
            for (const auto & item : optimized_ddls)
                ddls.emplace_back(item.second);
            write(optimized_file.value(), ddls);