Method getModifiedQueryInfo

src/Storages/StorageMerge.cpp:1078–1211

}

SelectQueryInfo ReadFromMerge::getModifiedQueryInfo(const ContextMutablePtr & modified_context,
    const StorageWithLockAndName & storage_with_lock_and_name,
    const StorageSnapshotPtr & storage_snapshot_,
    Names required_column_names,
    Names & column_names_as_aliases,
    bool & is_smallest_column_requested,
    Aliases & aliases) const
{
    const auto & [database_name, storage, storage_lock, table_name] = storage_with_lock_and_name;
    const StorageID current_storage_id = storage->getStorageID();

    SelectQueryInfo modified_query_info = query_info;

    modified_query_info.initial_storage_snapshot = merge_storage_snapshot;

    if (modified_query_info.planner_context)
        modified_query_info.planner_context = std::make_shared<PlannerContext>(modified_context, modified_query_info.planner_context);

    if (modified_query_info.table_expression)
    {
        auto replacement_table_expression = std::make_shared<TableNode>(storage, storage_lock, storage_snapshot_);
        replacement_table_expression->setAlias(modified_query_info.table_expression->getAlias());
        if (query_info.table_expression_modifiers)
            replacement_table_expression->setTableExpressionModifiers(*query_info.table_expression_modifiers);

        modified_query_info.query_tree = replaceTableExpressionAndRemoveJoin(modified_query_info.query_tree, modified_query_info.table_expression, replacement_table_expression, modified_context, required_column_names);
        modified_query_info.table_expression = replacement_table_expression;
        modified_query_info.planner_context->getOrCreateTableExpressionData(replacement_table_expression);

        auto get_column_options = GetColumnsOptions(GetColumnsOptions::All).withSubcolumns(storage_snapshot_->storage.supportsSubcolumns()).withVirtuals(VirtualsKind::All, VirtualsMaterializationPlace::All);

        /// Replace references to columns that don't exist in this child table with default values.
        /// This happens when merge() is used over tables with different schemas and the processing
        /// stage is above FetchColumns (e.g., for distributed/remote tables where the full query
        /// is sent to the child for processing).
        std::unordered_map<std::string, QueryTreeNodePtr> column_name_to_node;
        for (const auto & column_name : required_column_names)
        {
            if (column_name_to_node.contains(column_name))
                continue;

            if (storage_snapshot_->tryGetColumn(get_column_options, column_name))
                continue;

            auto merge_column = merge_storage_snapshot->tryGetColumn(
                GetColumnsOptions(GetColumnsOptions::All).withVirtuals(VirtualsKind::All, VirtualsMaterializationPlace::All)
                    .withSubcolumns(merge_storage_snapshot->storage.supportsSubcolumns()),
                column_name);
            if (!merge_column)
                continue;

            column_name_to_node.emplace(column_name,
                std::make_shared<ConstantNode>(merge_column->type->getDefault(), merge_column->type));
        }

        auto storage_columns = storage_snapshot_->metadata->getColumns();

        bool with_aliases = /* common_processed_stage == QueryProcessingStage::FetchColumns && */ !storage_columns.getAliases().empty();