Method resolveGroupByNode

src/Analyzer/Resolve/QueryAnalyzer.cpp:3877–3936

Resolve GROUP BY clause. */

/** Resolve GROUP BY clause.
  */
void QueryAnalyzer::resolveGroupByNode(QueryNode & query_node_typed, IdentifierResolveScope & scope)
{
    QueryTreeNodes nullable_group_by_keys;

    if (query_node_typed.isGroupByWithGroupingSets())
    {
        for (auto & grouping_sets_keys_list_node : query_node_typed.getGroupBy().getNodes())
        {
            replaceNodesWithPositionalArguments(grouping_sets_keys_list_node, query_node_typed.getProjection().getNodes(), scope);

            resolveExpressionNodeList(grouping_sets_keys_list_node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

            // Remove redundant calls to `tuple` function. It simplifies checking if expression is an aggregation key.
            // It's required to support queries like: SELECT number FROM numbers(3) GROUP BY (number, number % 2)
            auto & group_by_list = grouping_sets_keys_list_node->as<ListNode &>().getNodes();
            expandTuplesInList(group_by_list);
        }

        for (const auto & grouping_set : query_node_typed.getGroupBy().getNodes())
        {
            for (const auto & group_by_elem : grouping_set->as<ListNode>()->getNodes())
            {
                validateGroupByKeyType(group_by_elem->getResultType(), scope);
                if (scope.group_by_use_nulls)
                    nullable_group_by_keys.push_back(group_by_elem);
            }
        }
    }
    else
    {
        replaceNodesWithPositionalArguments(query_node_typed.getGroupByNode(), query_node_typed.getProjection().getNodes(), scope);

        resolveExpressionNodeList(query_node_typed.getGroupByNode(), scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);

        // Remove redundant calls to `tuple` function. It simplifies checking if expression is an aggregation key.
        // It's required to support queries like: SELECT number FROM numbers(3) GROUP BY (number, number % 2)
        auto & group_by_list = query_node_typed.getGroupBy().getNodes();
        expandTuplesInList(group_by_list);

        for (const auto & group_by_elem : query_node_typed.getGroupBy().getNodes())
        {
            validateGroupByKeyType(group_by_elem->getResultType(), scope);
            if (scope.group_by_use_nulls)
                nullable_group_by_keys.push_back(group_by_elem);
        }
    }

    if (!nullable_group_by_keys.empty())
        registerNullableGroupByKeys(nullable_group_by_keys, scope);

    /// With group_by_use_nulls the projection (and the other clauses) are re-resolved after GROUP BY
    /// so that expressions equal to a key become Nullable via the scope.nullable_group_by_keys
    /// lookup. Clear the resolution caches so that this re-resolution actually re-runs instead of
    /// reusing the non-Nullable results cached during the first resolution.
    if (!scope.nullable_group_by_keys.empty())
    {
        resolved_expressions.clear();
        scope.clearIdentifierCache();