Function executeQueryImpl

src/Interpreters/executeQuery.cpp:797–1864

}

static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
    const char * begin,
    const char * end,
    ASTPtr input_ast,
    ContextMutablePtr context,
    bool internal,
    QueryProcessingStage::Enum stage,
    bool has_query_tail,
    ReadBuffer * istr)
{
    const auto current_time = std::chrono::system_clock::now();
    context->setQueryContext(context);

    auto & client_info = context->getClientInfo();

    // If it's not an internal query and we don't see an initial_query_start_time yet, initialize it
    // to current time. Internal queries are those executed without an independent client context,
    // thus should not set initial_query_start_time, because it might introduce data race. It's also
    // possible to have unset initial_query_start_time for non-internal and non-initial queries. For
    // example, the query is from an initiator that is running an old version of clickhouse.
    if (!internal && client_info.initial_query_start_time == 0)
    {
        client_info.initial_query_start_time = time_in_seconds(current_time);
        client_info.initial_query_start_time_microseconds = time_in_microseconds(current_time);
    }

#if !defined(ARCADIA_BUILD)
    assert(internal || CurrentThread::get().getQueryContext());
    assert(internal || CurrentThread::get().getQueryContext()->getCurrentQueryId() == CurrentThread::getQueryId());
#endif

    const Settings & settings = context->getSettingsRef();

    /// FIXME: Use global join for cnch join works for sql mode first.
    /// Will be replaced by distributed query after @youzhiyuan add query plan runtime.
    if (context->getServerType() == ServerType::cnch_server)
    {
        context->setSetting("distributed_product_mode", String{"global"});
    }

    ASTPtr ast;
    const char * query_end;

    /// Don't limit the size of internal queries.
    size_t max_query_size = 0;
    if (!internal)
        max_query_size = settings.max_query_size;

    auto finish_current_transaction = [ast](const ContextPtr & query_context) {
        if (auto cur_txn = query_context->getCurrentTransaction(); cur_txn)
        {
            if (query_context->getServerType() == ServerType::cnch_server)
            {
                query_context->getCnchTransactionCoordinator().finishTransaction(cur_txn);
            }
        }
    };