Method resolveTableFunction

src/Analyzer/Resolve/QueryAnalyzer.cpp:4374–4791

Resolve table function node in scope

/// Resolve table function node in scope
void QueryAnalyzer::resolveTableFunction(QueryTreeNodePtr & table_function_node,
    IdentifierResolveScope & scope,
    QueryExpressionsAliasVisitor & expressions_visitor,
    bool nested_table_function)
{
    auto & table_function_node_typed = table_function_node->as<TableFunctionNode &>();

    if (!nested_table_function)
        expressions_visitor.visit(table_function_node_typed.getArgumentsNode());

    const auto & table_function_name = table_function_node_typed.getTableFunctionName();

    auto & scope_context = scope.context;

    TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().tryGet(table_function_name, scope_context);
    if (!table_function_ptr)
    {
        String database_name = scope_context->getCurrentDatabase();
        String table_name;

        auto function_ast = table_function_node->toAST();
        Identifier table_identifier{table_function_name};
        if (table_identifier.getPartsSize() == 1)
        {
            table_name = table_identifier[0];
        }
        else if (table_identifier.getPartsSize() == 2)
        {
            database_name = table_identifier[0];
            table_name = table_identifier[1];
        }

        /// Collect parameterized view arguments
        NameToNameMap view_params;
        for (const auto & argument : table_function_node_typed.getArguments())
        {
            if (auto * arg_func = argument->as<FunctionNode>())
            {
                if (arg_func->getFunctionName() != "equals")
                    continue;

                auto nodes = arg_func->getArguments().getNodes();
                if (nodes.size() != 2)
                    continue;

                if (auto * identifier_node = nodes[0]->as<IdentifierNode>())
                {
                    resolveExpressionNode(nodes[1], scope, /* allow_lambda_expression */false, /* allow_table_function */false);
                    if (auto * constant = nodes[1]->as<ConstantNode>())
                    {
                        /// Serialize the constant value using datatype specific
                        /// interfaces to match the deserialization in ReplaceQueryParametersVistor.
                        WriteBufferFromOwnString buf;
                        const auto & value = constant->getValue();
                        auto real_type = constant->getResultType();
                        auto temporary_column  = real_type->createColumn();
                        temporary_column->insert(value);
                        real_type->getDefaultSerialization()->serializeTextEscaped(*temporary_column, 0, buf, {});