Method execute

programs/benchmark/Benchmark.cpp:717–805

    }

    void execute(const Query & query, size_t connection_index)
    {
        Stopwatch watch;

        std::shared_ptr<IntervalStats> cur_interval;
        if (precise)
        {
            std::lock_guard lock(interval_mutex);
            cur_interval = interval;
        }

        ConnectionPool::Entry entry = connections[connection_index]->get(ConnectionTimeouts::getTCPTimeoutsWithoutFailover(settings));

        bool should_reconnect = false;
        {
            std::lock_guard lock(queries_per_connection_mutex);
            should_reconnect = reconnect > 0 && (++queries_per_connection[connection_index] % reconnect == 0);
        }

        if (should_reconnect)
            entry->disconnect();

        RemoteQueryExecutor executor(*entry, query, std::make_shared<const Block>(), global_context, nullptr, Scalars(), Tables(), query_processing_stage);

        if (!query_id.empty())
            executor.setQueryId(query_id);
        else if (!query_id_prefix.empty())
            executor.setQueryId(query_id_prefix + "_" + Poco::UUIDGenerator().createRandom().toString());

        Progress progress;
        executor.setProgressCallback([&progress](const Progress & value) { progress.incrementPiecewiseAtomically(value); });

        executor.sendQuery(ClientInfo::QueryKind::INITIAL_QUERY);

        ProfileInfo info;
        for (Block block = executor.readBlock(); !block.empty(); block = executor.readBlock())
            info.update(block);

        executor.finish();

        watch.stop();
        double duration = (display_client_side_time || progress.elapsed_ns == 0)
            ? watch.elapsedSeconds()
            : static_cast<double>(progress.elapsed_ns) / 1e9;
        size_t info_index = round_robin ? 0 : connection_index;

        if (precise && cur_interval)
        {
            // Stats weighting across all overlapped intervals
            UInt64 duration_ns = watch.getEnd() - watch.getStart();

            std::lock_guard lock(interval_mutex);

            // Distribute weights across intervals intersecting query execution span
            // Intervals:
            // [beg]    I0: [s0---------e0)
            //          I1:               [s1--------------e1)
            // [end]    I2:               |                  [s2-----------e2)