Method generate

src/Storages/StorageMergeTreeIndex.cpp:64–171

protected:
    Chunk generate() override
    {
        if (part_index >= data_parts.size())
            return {};

        auto component_guard = Coordination::setCurrentComponent("MergeTreeIndexSource::generate");

        const auto & part = data_parts[part_index];
        const auto & index_granularity = part->index_granularity;

        std::shared_ptr<MergeTreeMarksLoader> marks_loader;
        if (with_marks && isCompactPart(part))
        {
            marks_loader = createMarksLoader(
                part,
                MergeTreeDataPartCompact::DATA_FILE_NAME,
                part->index_granularity_info.mark_type.with_substreams ? part->getColumnsSubstreams().getTotalSubstreams()
                                                                       : part->getColumns().size());
        }

        size_t num_columns = header->columns();
        size_t num_rows = index_granularity->getMarksCount();

        const auto & part_name_column = StorageMergeTreeIndex::part_name_column;
        const auto & mark_number_column = StorageMergeTreeIndex::mark_number_column;
        const auto & rows_in_granule_column = StorageMergeTreeIndex::rows_in_granule_column;
        IMergeTreeDataPart::IndexPtr index_ptr;

        Columns result_columns(num_columns);
        for (size_t pos = 0; pos < num_columns; ++pos)
        {
            const auto & column_name = header->getByPosition(pos).name;
            const auto & column_type = header->getByPosition(pos).type;

            if (index_header->has(column_name))
            {
                if (!index_ptr)
                    index_ptr = part->getIndex();

                size_t index_position = index_header->getPositionByName(column_name);

                /// Some of the columns from suffix of primary index may be not loaded
                /// according to setting 'primary_key_ratio_of_unique_prefix_values_to_skip_suffix_columns'.
                if (index_position < index_ptr->size())
                {
                    result_columns[pos] = index_ptr->at(index_position);
                }
                else
                {
                    auto index_column = column_type->createColumnConstWithDefaultValue(num_rows);
                    result_columns[pos] = index_column->convertToFullColumnIfConst();
                }
            }
            else if (minmax_header && minmax_header->has(column_name))
            {
                FieldRef min_value(Null{});
                FieldRef max_value(Null{});