Method parseArguments

src/TableFunctions/TableFunctionExplain.cpp:79–148

}

void TableFunctionExplain::parseArguments(const ASTPtr & ast_function, ContextPtr context)
{
    const auto * function = ast_function->as<ASTFunction>();
    if (!function || !function->arguments)
        throw Exception(ErrorCodes::BAD_ARGUMENTS,
            "Table function '{}' cannot be called directly, use `SELECT * FROM (EXPLAIN ...)` syntax", getName());

    size_t num_args = function->arguments->children.size();
    if (num_args != 2 && num_args != 3)
        throw Exception(ErrorCodes::BAD_ARGUMENTS,
            "Table function '{}' requires 2 or 3 arguments, got {}", getName(), num_args);

    const auto & kind_arg = function->arguments->children[0];
    const auto * kind_literal = kind_arg->as<ASTLiteral>();
    if (!kind_literal || kind_literal->value.getType() != Field::Types::String)
        throw Exception(ErrorCodes::BAD_ARGUMENTS,
            "Table function '{}' requires a String argument for EXPLAIN kind, got '{}'",
            getName(), kind_arg->formatForErrorMessage());

    ASTExplainQuery::ExplainKind kind = ASTExplainQuery::fromString(kind_literal->value.safeGet<String>());
    auto explain_query = make_intrusive<ASTExplainQuery>(kind);

    const auto * settings_arg = function->arguments->children[1]->as<ASTLiteral>();
    if (!settings_arg || settings_arg->value.getType() != Field::Types::String)
        throw Exception(ErrorCodes::BAD_ARGUMENTS,
            "Table function '{}' requires a serialized string settings argument, got '{}'",
            getName(), function->arguments->children[1]->formatForErrorMessage());

    const auto & settings_str = settings_arg->value.safeGet<String>();
    if (!settings_str.empty())
    {
        const Settings & settings = context->getSettingsRef();

        /// parse_only_internals_ = true - we don't want to parse `SET` keyword
        ParserSetQuery settings_parser(/* parse_only_internals_ = */ true);
        ASTPtr settings_ast = parseQuery(
            settings_parser, settings_str, settings[Setting::max_query_size], settings[Setting::max_parser_depth], settings[Setting::max_parser_backtracks]);
        explain_query->setSettings(std::move(settings_ast));
    }

    if (function->arguments->children.size() > 2)
    {
        const auto & subquery_arg = function->arguments->children[2];
        const auto * subquery = subquery_arg->as<ASTSubquery>();

        if (!subquery)
            throw Exception(ErrorCodes::BAD_ARGUMENTS,
                "Table function '{}' requires a subquery argument, got '{}'",
                getName(), subquery_arg->formatForErrorMessage());

        if (subquery->children.empty())
            throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE,
                "A subquery AST element must have a child");

        const auto & query_arg = subquery->children[0];

        if (!query_arg->as<ASTSelectWithUnionQuery>())
            throw Exception(ErrorCodes::BAD_ARGUMENTS,