Method createExternalTables

src/Server/GRPCServer.cpp:962–1057

    }

    void Call::createExternalTables()
    {
        while (true)
        {
            for (const auto & external_table : query_info.external_tables())
            {
                String name = external_table.name();
                if (name.empty())
                    name = "_data";
                auto temporary_id = StorageID::createEmpty();
                temporary_id.table_name = name;

                /// If such a table does not exist, create it.
                StoragePtr storage;
                if (auto resolved = query_context->tryResolveStorageID(temporary_id, Context::ResolveExternal))
                {
                    storage = DatabaseCatalog::instance().getTable(resolved, query_context);
                }
                else
                {
                    NamesAndTypesList columns;
                    for (size_t column_idx : collections::range(external_table.columns_size()))
                    {
                        const auto & name_and_type = external_table.columns(column_idx);
                        NameAndTypePair column;
                        column.name = name_and_type.name();
                        if (column.name.empty())
                            column.name = "_" + std::to_string(column_idx + 1);
                        column.type = DataTypeFactory::instance().get(name_and_type.type());
                        columns.emplace_back(std::move(column));
                    }
                    auto temporary_table = TemporaryTableHolder(query_context, ColumnsDescription{columns}, {}, {}, {});
                    storage = temporary_table.getTable();
                    query_context->addExternalTable(temporary_id.table_name, std::move(temporary_table));
                }

                if (!external_table.data().empty())
                {
                    /// The data will be written directly to the table.
                    auto metadata_snapshot = storage->getInMemoryMetadataPtr();
                    auto out_stream = storage->write(ASTPtr(), metadata_snapshot, query_context);
                    ReadBufferFromMemory data(external_table.data().data(), external_table.data().size());
                    String format = external_table.format();
                    if (format.empty())
                        format = "TabSeparated";
                    ContextMutablePtr external_table_context = query_context;
                    ContextMutablePtr temp_context;
                    if (!external_table.settings().empty())
                    {
                        temp_context = Context::createCopy(query_context);
                        external_table_context = temp_context;
                        SettingsChanges settings_changes;
                        for (const auto & [key, value] : external_table.settings())
                            settings_changes.push_back({key, value});
                        external_table_context->checkSettingsConstraints(settings_changes);
                        external_table_context->applySettingsChanges(settings_changes);
                    }
                    auto in_stream = external_table_context->getInputFormat(