Method visitFunction

src/Planner/PlannerActionsVisitor.cpp:1191–1321

}

PlannerActionsVisitorImpl::NodeNameAndNodeMinLevel PlannerActionsVisitorImpl::visitFunction(const QueryTreeNodePtr & node)
{
    const auto & function_node = node->as<FunctionNode &>();

    if (function_node.getFunctionName() == "indexHint")
        return visitIndexHintFunction(node);
    if (function_node.getFunctionName() == "exists")
        return visitExistsFunction(node);

    std::optional<NodeNameAndNodeMinLevel> in_function_second_argument_node_name_with_level;

    if (isNameOfInFunction(function_node.getFunctionName()))
        in_function_second_argument_node_name_with_level = makeSetForInFunction(node);

    auto function_node_name = action_node_name_helper.calculateActionNodeName(node);

    /* Aggregate functions, window functions, and GROUP BY expressions were already analyzed in the previous steps.
     * If we have already visited some expression, we don't need to revisit it or its arguments again.
     * For example, the expression from the aggregation step is also present in the projection:
     *    SELECT foo(a, b, c) as x FROM table GROUP BY foo(a, b, c)
     * In this case we should not analyze `a`, `b`, `c` again.
     * Moreover, it can lead to an error if we have arrayJoin in the arguments because it will be calculated twice.
     *
     * The expression can also be present as a constant COLUMN node: when a GROUP BY key expression
     * is constant-foldable, the aggregation step exposes it as a constant column, and the ActionsDAG
     * constructor duplicates constant inputs as COLUMN nodes. Visiting the arguments in this case can
     * lead to an error: for example, after aggregation with group_by_use_nulls, GROUP BY key constants
     * are wrapped into Nullable but keep their names, and a lambda capture built over such a constant
     * fails with a type mismatch.
     */
    bool is_input_node = function_node.isAggregateFunction() || function_node.isWindowFunction()
        || actions_stack.front().containsInputOrConstantNode(function_node_name);
    if (is_input_node)
    {
        size_t actions_stack_size = actions_stack.size();

        for (size_t i = 0; i < actions_stack_size; ++i)
        {
            auto & actions_stack_node = actions_stack[i];
            actions_stack_node.addInputColumnIfNecessary(function_node_name, function_node.getResultType());
        }

        return {function_node_name, Levels(0)};
    }

    const auto & function_arguments = function_node.getArguments().getNodes();
    size_t function_arguments_size = function_arguments.size();

    Names function_arguments_node_names;
    function_arguments_node_names.reserve(function_arguments_size);

    Levels levels(0);
    for (size_t function_argument_index = 0; function_argument_index < function_arguments_size; ++function_argument_index)
    {
        if (in_function_second_argument_node_name_with_level && function_argument_index == 1)
        {
            auto & [node_name, node_levels] = *in_function_second_argument_node_name_with_level;
            function_arguments_node_names.push_back(std::move(node_name));