Method appendGroupBy

src/Interpreters/ExpressionAnalyzer.cpp:1445–1497

}

bool SelectQueryExpressionAnalyzer::appendGroupBy(ExpressionActionsChain & chain, bool only_types, bool optimize_aggregation_in_order,
                                                  ManyExpressionActions & group_by_elements_actions)
{
    const auto * select_query = getAggregatingQuery();

    if (!select_query->groupBy())
        return false;

    ExpressionActionsChainSteps::Step & step = chain.lastStep(columns_after_join);

    ASTs asts = select_query->groupBy()->children;
    NameSet group_by_keys;
    if (select_query->group_by_with_grouping_sets)
    {
        for (const auto & ast : asts)
        {
            for (const auto & ast_element : ast->children)
            {
                step.addRequiredOutput(ast_element->getColumnName());
                group_by_keys.insert(ast_element->getColumnName());
                getRootActions(ast_element, only_types, step.actions()->dag);
            }
        }
    }
    else
    {
        for (const auto & ast : asts)
        {
            step.addRequiredOutput(ast->getColumnName());
            group_by_keys.insert(ast->getColumnName());
            getRootActions(ast, only_types, step.actions()->dag);
        }
    }

    for (const auto & result_column : step.getResultColumns())
    {
        if (group_by_keys.contains(result_column.name))
            validateGroupByKeyType(result_column.type);
    }

    if (optimize_aggregation_in_order)
    {
        for (auto & child : asts)
        {
            ActionsDAG actions_dag(columns_after_join);
            getRootActions(child, only_types, actions_dag);
            group_by_elements_actions.emplace_back(
                std::make_shared<ExpressionActions>(std::move(actions_dag), ExpressionActionsSettings(getContext(), CompileExpressions::yes)));
        }
    }

    return true;
}

void SelectQueryExpressionAnalyzer::validateGroupByKeyType(const DB::DataTypePtr & key_type) const
{