Method finishQuery

src/Interpreters/QueryMetricLog.cpp:180–253

}

void QueryMetricLog::finishQuery(const String & query_id, TimePoint finish_time, QueryStatusInfoPtr query_info)
{
    /// Test-only failpoint placed before `queries_mutex` so a concurrent periodic
    /// `collectMetric` can overtake `finishQuery` and advance `info.last_collect_time`
    /// past `finish_time`. The gate on `query_info` and the dedicated query-id prefix
    /// ensures unrelated traffic is unaffected even when the failpoint is enabled.
    /// The `query_info` gate filters `nullptr` finish paths. If a non-null phantom
    /// finish-call still reaches this failpoint, `it == queries.end()` after resume
    /// makes this function return immediately.
    if (query_info && FailPointInjection::hasAnyFailPointBeenRegistered()
        && query_id.starts_with(query_metric_log_final_row_failpoint_query_id_prefix))
        FailPointInjection::pauseFailPoint(FailPoints::query_metric_log_pause_before_finish);

    UniqueLock global_lock(queries_mutex);
    auto it = queries.find(query_id);

    /// finishQuery may be called from logExceptionBeforeStart when the query has not even started
    /// yet, so its corresponding startQuery is never called.
    if (it == queries.end())
        return;

    auto & query_status = it->second;

    /// Get a refcounted reference to the mutex to ensure it's not destroyed until the query is
    /// removed from queries. Otherwise, query_lock would attempt to unlock a non-existing mutex.
    auto mutex = query_status.mutex;
    UniqueLock query_lock(query_status.getMutex());

    /// finishQuery may be called twice for the same query_id if a new query with the same query_id
    /// is attempted to run in case replace_running_query=0 (the default). Make sure we only execute
    /// the finishQuery once.
    auto thread_id = CurrentThread::get().thread_id;
    if (thread_id != query_status.thread_id || query_status.finished)
    {
        LOG_TEST(logger, "Query {} finished from a different thread_id than the one it started it: "
                         "original was {}, this one is {}. Ignoring this finishQuery",
                         query_id, query_status.thread_id, thread_id);
        return;
    }

    setQueryFinished(query_status);
    global_lock.unlock();

    if (query_info)
    {
        auto elem = query_status.createLogMetricElement(query_id, *query_info, finish_time, /* is_final = */ true);
        if (elem)
            add(std::move(elem.value()));
    }

    /// The task has an `exec_mutex` locked while being executed. This same mutex is locked when
    /// deactivating the task, which happens automatically on its destructor. Thus, we cannot
    /// deactivate/destroy the task while it's running. Now, the task locks `queries_mutex` to
    /// prevent concurrent edition of the `queries`. In short, the mutex order is: `exec_mutex` ->
    /// `queries_mutex` -> `query_status.mutex`. So, to prevent a deadlock we need to make sure that
    /// we always lock them in that order.
    {
        /// Take ownership of the task so that we can destroy it in this scope after unlocking `queries_mutex`.