Method StorageMaterializedView

src/Storages/StorageMaterializedView.cpp:115–336

}

StorageMaterializedView::StorageMaterializedView(
    const StorageID & table_id_,
    ContextPtr local_context,
    const ASTCreateQuery & query,
    const ColumnsDescription & columns_,
    LoadingStrictnessLevel mode,
    const String & comment,
    bool is_restore_from_backup)
    : StorageWithCommonVirtualColumns(table_id_), WithMutableContext(local_context->getGlobalContext())
{
    StorageInMemoryMetadata storage_metadata;
    storage_metadata.setColumns(columns_);

    if (query.sql_security)
        storage_metadata.setSQLSecurity(query.sql_security->as<ASTSQLSecurity &>());

    /// Materialized view doesn't support SQL SECURITY INVOKER.
    if (storage_metadata.sql_security_type == SQLSecurityType::INVOKER)
        throw Exception(ErrorCodes::QUERY_IS_NOT_SUPPORTED_IN_MATERIALIZED_VIEW, "SQL SECURITY INVOKER can't be specified for MATERIALIZED VIEW");

    if (storage_metadata.sql_security_type == SQLSecurityType::DEFINER)
        ViewDefinerDependencies::instance().addViewDependency(*storage_metadata.definer, table_id_);

    if (!query.select)
        throw Exception(ErrorCodes::INCORRECT_QUERY, "SELECT query is not specified for {}", getName());

    /// If the destination table is not set, use inner table
    auto to_table_id = query.getTargetTableID(ViewTarget::To);
    has_inner_table = to_table_id.empty();
    auto to_inner_uuid = query.getTargetInnerUUID(ViewTarget::To);
    auto * to_table_engine = query.getTargetInnerEngine(ViewTarget::To);

    if (has_inner_table && !to_table_engine)
        throw Exception(ErrorCodes::INCORRECT_QUERY,
                        "You must specify where to save results of a MaterializedView query: "
                        "either ENGINE or an existing table in a TO clause");

    if (to_table_engine && to_table_engine->primary_key)
        storage_metadata.primary_key = KeyDescription::getKeyFromAST(to_table_engine->primary_key->ptr(),
                                                                     storage_metadata.columns,
                                                                     {},
                                                                     local_context->getGlobalContext());
    /// Use the database where the materialized view is created to resolve nested views
    ContextMutablePtr mv_db_context = Context::createCopy(local_context);
    mv_db_context->setCurrentDatabase(table_id_.database_name);

    auto select = SelectQueryDescription::getSelectQueryFromASTForMatView(query.select->clone(), query.refresh_strategy != nullptr, mv_db_context);
    if (select.select_table_id)
    {
        auto select_table_dependent_views = DatabaseCatalog::instance().getDependentViews(select.select_table_id);

        auto max_materialized_views_count_for_table = getContext()->getServerSettings()[ServerSetting::max_materialized_views_count_for_table];
        if (max_materialized_views_count_for_table && select_table_dependent_views.size() >= max_materialized_views_count_for_table)
            throw Exception(ErrorCodes::TOO_MANY_MATERIALIZED_VIEWS,
                            "Too many materialized views, maximum: {}", max_materialized_views_count_for_table.value);
    }

    storage_metadata.setSelectQuery(select);