Method getInputOrderImpl

src/Storages/ReadInOrderOptimizer.cpp:203–285

}

InputOrderInfoPtr ReadInOrderOptimizer::getInputOrderImpl(
    const StorageMetadataPtr & metadata_snapshot,
    const SortDescription & description,
    const ManyExpressionActions & actions,
    const ContextPtr & context,
    UInt64 limit) const
{
    const Names & sorting_key_columns = metadata_snapshot->getSortingKeyColumns();
    /// read_direction will be set from the first non-constant ORDER BY column
    int read_direction = 0;

    auto fixed_sorting_columns = getFixedSortingColumns(query, sorting_key_columns, context);

    SortDescription sort_description_for_merging;
    sort_description_for_merging.reserve(description.size());

    size_t desc_pos = 0;
    size_t key_pos = 0;

    while (desc_pos < description.size() && key_pos < sorting_key_columns.size())
    {
        if (forbidden_columns.contains(description[desc_pos].column_name))
            break;

        auto match = matchSortDescriptionAndKey(actions[desc_pos]->getActions(), description[desc_pos], sorting_key_columns[key_pos]);

        /// If the ORDER BY column matches a fixed (constant) key column,
        /// add it to the sort description but don't let it set read_direction.
        /// Example: ORDER BY tenant, event_time DESC with WHERE tenant='42'
        /// The 'tenant' column is constant, so read direction should come from event_time DESC.
        if (match.direction && fixed_sorting_columns.contains(sorting_key_columns[key_pos]))
        {
            /// Still add to sort description - the column matches, it's just constant
            sort_description_for_merging.push_back(description[desc_pos]);
            ++desc_pos;
            ++key_pos;
            continue;
        }

        bool is_matched = match.direction && (read_direction == 0 || match.direction == read_direction);

        if (!is_matched)
        {
            /// If one of the sorting columns is constant after filtering,
            /// skip it, because it won't affect order anymore.
            if (fixed_sorting_columns.contains(sorting_key_columns[key_pos]))
            {
                ++key_pos;
                continue;
            }

            break;
        }

        if (read_direction == 0)
            read_direction = match.direction;

        sort_description_for_merging.push_back(description[desc_pos]);