Function validateCreateQuery

src/Databases/DatabasesCommon.cpp:59–139

namespace
{
void validateCreateQuery(const ASTCreateQuery & query, const VirtualColumnsDescription & virtuals, ContextPtr context)
{
    /// First validate that the query can be parsed
    const auto serialized_query = query.formatWithSecretsOneLine();
    ParserCreateQuery parser;
    ASTPtr new_query_raw = parseQuery(
        parser,
        serialized_query.data(),
        serialized_query.data() + serialized_query.size(),
        "after altering table ",
        0,
        context->getSettingsRef()[Setting::max_parser_depth],
        context->getSettingsRef()[Setting::max_parser_backtracks]);
    const auto & new_query = new_query_raw->as<const ASTCreateQuery &>();
    /// If there are no columns, then there is nothing much we can do
    if (!new_query.columns_list || !new_query.columns_list->columns)
        return;

    const auto & columns = *new_query.columns_list;
    /// Do some basic sanity checks. We cannot do the same strict checks as on create, because context might not have the same settings if it is not called directly from an alter query.
    /// SECONDARY_CREATE should check most of the important things.
    const auto columns_desc
        = InterpreterCreateQuery::getColumnsDescription(*columns.columns, context, LoadingStrictnessLevel::SECONDARY_CREATE, false);

    if (columns_desc.getInsertable().empty())
        throw Exception(ErrorCodes::EMPTY_LIST_OF_COLUMNS_PASSED, "Cannot CREATE table without insertable columns");

    /// Default expressions are only validated in level CREATE, so let's check them now
    DefaultExpressionsInfo default_expr_info{make_intrusive<ASTExpressionList>()};

    for (const auto & ast : columns.columns->children)
    {
        const auto & col_decl = ast->as<ASTColumnDeclaration &>();
        /// There might be some special columns for which `columns_desc.get` would throw, e.g. Nested column when flatten_nested is enabled.
        /// At the time of writing I am not aware of anything else, but my knowledge is limited and new types might be added, so let's be safe.
        if (!col_decl.getDefaultExpression())
            continue;

        /// If no column description for the name, let's skip the validation of default expressions, but let's log the fact that something went wrong
        if (const auto * maybe_column_desc = columns_desc.tryGet(col_decl.name); maybe_column_desc)
            getDefaultExpressionInfoInto(col_decl, maybe_column_desc->type, default_expr_info);
        else
            LOG_WARNING(getLogger("validateCreateQuery"), "Couldn't get column description for column {}", col_decl.name);
    }

    if (default_expr_info.expr_list)
        validateColumnsDefaultsAndGetSampleBlock(default_expr_info.expr_list, columns_desc.getAll(), context);

    constexpr bool escape_index_filenames = true; /// We don't care, we are only doing validation and discarding the result
    bool is_implicitly_created = false; /// Same
    if (columns.indices)
    {
        for (const auto & child : columns.indices->children)
            IndexDescription::getIndexFromAST(child, columns_desc, is_implicitly_created, escape_index_filenames, context);
    }
    if (columns.constraints)
    {
        InterpreterCreateQuery::getConstraintsDescription(columns.constraints, columns_desc, context);