Method RetryQueryFromThread

be/src/runtime/query-driver.cc:271–453

}

void QueryDriver::RetryQueryFromThread(
    const Status& error, const shared_ptr<QueryDriver>& query_driver) {
  // This method does not require holding the ClientRequestState::lock_ for the original
  // query. This ensures that the client can still interact (e.g. poll the state) of the
  // original query while the new query is being created. This is necessary as it might
  // take a non-trivial amount of time to setup and start running the new query.

  bool orig_do_trace = false;

  DCHECK(query_driver.get() == this);
  const TUniqueId& query_id = client_request_state_->query_id();
  VLOG_QUERY << Substitute(
      "Retrying query $0 with error message $1", PrintId(query_id), error.GetDetail());

  // There should be no retried client request state.
  ClientRequestState* request_state;
  {
    lock_guard<SpinLock> l(client_request_state_lock_);
    DCHECK(retried_client_request_state_ == nullptr);
    DCHECK(client_request_state_ != nullptr);
    request_state = client_request_state_.get();
    orig_do_trace = request_state->otel_trace_query();
  }
  DCHECK(request_state->retry_state() == ClientRequestState::RetryState::RETRYING)
      << Substitute("query=$0 unexpected state $1", PrintId(request_state->query_id()),
          request_state->ExecStateToString(request_state->exec_state()));

  shared_ptr<ImpalaServer::SessionState> session = request_state->session();

  // Cancel the query. We don't worry about whether it's inflight because (1) a retry can
  // be triggered when the query is in the INITIALIZED state, and (2) the user could have
  // already cancelled the query.
  request_state->Cancel(nullptr);

  unique_ptr<ClientRequestState> retry_request_state = nullptr;
  CreateRetriedClientRequestState(request_state, &retry_request_state, &session);
  DCHECK(retry_request_state != nullptr);

  const TUniqueId& retry_query_id = retry_request_state->query_id();
  VLOG_QUERY << Substitute("Retrying query $0 with new query id $1", PrintId(query_id),
      PrintId(retry_query_id));

  // The steps below mimic what is done when a query is first launched. See
  // ImpalaServer::ExecuteStatement.

  // Mark the session as active. This is necessary because a ScopedSessionState may not
  // actively be opened at this time. A reference to the session (SessionState::ref_count)
  // is necessary when calling ImpalaServer::RegisterQuery with the session. Furthermore,
  // a reference to the session is necessary to ensure that the session does not get
  // expired while the retry is running.
  parent_server_->MarkSessionActive(session);

  // A QueryHandle instance is required for a few of the methods called below.
  QueryHandle retry_query_handle;
  retry_query_handle.SetHandle(query_driver, retry_request_state.get());

  // Register the new query.
  Status status =