hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
21c31706a5497a3539130306d605fd80829a573e
oceanbase/src/sql/engine/cmd/ob_ddl_executor_util.cpp
simonjoylet 39bb278e58 [FEAT MERGE] enhance_ddl_quality 
Co-authored-by: renju96 <fcbrenju@163.com>
2024-02-06 21:39:19 +00:00

336 lines
14 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#define USING_LOG_PREFIX SQL_ENG
#include "ob_ddl_executor_util.h"
#include "lib/utility/utility.h"
#include "lib/utility/ob_tracepoint.h"
#include "lib/worker.h"
#include "share/ob_common_rpc_proxy.h"
#include "share/ob_srv_rpc_proxy.h" //ObSrvRpcProxy
#include "share/ob_ddl_error_message_table_operator.h"
#include "sql/session/ob_sql_session_info.h"
#include "observer/ob_server_event_history_table_operator.h"
namespace oceanbase
{
using namespace common;
using namespace share;
using namespace share::schema;
using namespace observer;
namespace sql
{
int ObDDLExecutorUtil::handle_session_exception(ObSQLSessionInfo &session)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(session.is_query_killed())) {
ret = OB_ERR_QUERY_INTERRUPTED;
LOG_WARN("query is killed", K(ret));
} else if (OB_UNLIKELY(session.is_zombie())) {
ret = OB_SESSION_KILLED;
LOG_WARN("session is killed", K(ret));
} else if (GCTX.is_standby_cluster()) {
ret = OB_SESSION_KILLED;
LOG_INFO("cluster switchoverd, kill session", KR(ret));
}
return ret;
}
int ObDDLExecutorUtil::wait_ddl_finish(
const uint64_t tenant_id,
const int64_t task_id,
ObSQLSessionInfo *session,
obrpc::ObCommonRpcProxy *common_rpc_proxy,
const bool is_support_cancel)
{
int ret = OB_SUCCESS;
const int64_t retry_interval = 100 * 1000;
ObAddr unused_addr;
bool is_table_exist = false;
int64_t unused_user_msg_len = 0;
THIS_WORKER.set_timeout_ts(ObTimeUtility::current_time() + OB_MAX_USER_SPECIFIED_TIMEOUT);
ObDDLErrorMessageTableOperator::ObBuildDDLErrorMessage error_message;
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || task_id <= 0 || nullptr == common_rpc_proxy)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(task_id), KP(common_rpc_proxy));
} else {
SERVER_EVENT_ADD("ddl", "start wait ddl finish",
"tenant_id", tenant_id,
"ret", ret,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"rpc_dest", common_rpc_proxy->get_server());
LOG_INFO("start wait ddl finsih", K(task_id), "ddl_event_info", ObDDLEventInfo());
int tmp_ret = OB_SUCCESS;
bool is_tenant_dropped = false;
bool is_tenant_standby = false;
while (OB_SUCC(ret)) {
if (OB_SUCCESS == ObDDLErrorMessageTableOperator::get_ddl_error_message(
tenant_id, task_id, -1 /* target_object_id */, unused_addr, false /* is_ddl_retry_task */, *GCTX.sql_proxy_, error_message, unused_user_msg_len)) {
ret = error_message.ret_code_;
if (OB_SUCCESS != ret) {
FORWARD_USER_ERROR(ret, error_message.user_message_);
}
break;
} else {
if (OB_FAIL(ret)) {
} else if (OB_TMP_FAIL(ObDDLUtil::check_tenant_status_normal(GCTX.sql_proxy_, tenant_id))) {
if (OB_TENANT_HAS_BEEN_DROPPED == tmp_ret) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("tenant has been dropped", K(ret), K(tenant_id));
} else if (OB_STANDBY_READ_ONLY == tmp_ret) {
ret = OB_STANDBY_READ_ONLY;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("tenant is standby now, stop wait", K(ret), K(tenant_id));
}
}
if (OB_FAIL(ret)) {
} else if (nullptr != session && OB_FAIL(handle_session_exception(*session))) {
LOG_WARN("session exeception happened", K(ret), K(is_support_cancel));
if (is_support_cancel && OB_TMP_FAIL(cancel_ddl_task(tenant_id, common_rpc_proxy))) {
LOG_WARN("cancel ddl task failed", K(tmp_ret));
ret = OB_SUCCESS;
} else {
break;
}
}
if (OB_FAIL(ret)) {
} else if (is_server_stopped()) {
ret = OB_TIMEOUT;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("server is stopping, check whether the ddl task finish successfully or not", K(ret), K(tenant_id), K(task_id));
} else {
ob_usleep(retry_interval);
}
}
}
SERVER_EVENT_ADD("ddl", "end wait ddl finish",
"tenant_id", tenant_id,
"ret", error_message.ret_code_,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"rpc_dest", common_rpc_proxy->get_server());
LOG_INFO("finish wait ddl", K(ret), K(task_id), "ddl_event_info", ObDDLEventInfo(), K(error_message));
}
return ret;
}
int ObDDLExecutorUtil::wait_build_index_finish(const uint64_t tenant_id, const int64_t task_id, bool &is_finish)
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
bool is_tenant_dropped = false;
bool is_tenant_standby = false;
ObAddr unused_addr;
int64_t unused_user_msg_len = 0;
THIS_WORKER.set_timeout_ts(ObTimeUtility::current_time() + OB_MAX_USER_SPECIFIED_TIMEOUT);
share::ObDDLErrorMessageTableOperator::ObBuildDDLErrorMessage error_message;
is_finish = false;
SERVER_EVENT_ADD("ddl", "start wait build index finish",
"tenant_id", tenant_id,
"ret", ret,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"is_tenant_standby", is_tenant_standby);
LOG_INFO("start wait build index finish", K(task_id), "ddl_event_info", ObDDLEventInfo());
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || task_id <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K(tenant_id), K(task_id));
} else if (OB_SUCCESS == share::ObDDLErrorMessageTableOperator::get_ddl_error_message(
tenant_id, task_id, -1 /* target_object_id */, unused_addr, false /* is_ddl_retry_task */, *GCTX.sql_proxy_, error_message, unused_user_msg_len)) {
ret = error_message.ret_code_;
if (OB_SUCCESS != ret) {
FORWARD_USER_ERROR(ret, error_message.user_message_);
}
is_finish = true;
} else {
if (OB_FAIL(ret)) {
} else if (OB_TMP_FAIL(ObDDLUtil::check_tenant_status_normal(GCTX.sql_proxy_, tenant_id))) {
if (OB_TENANT_HAS_BEEN_DROPPED == tmp_ret) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("tenant has been dropped", K(ret), K(tenant_id));
} else if (OB_STANDBY_READ_ONLY == tmp_ret) {
ret = OB_STANDBY_READ_ONLY;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("tenant is standby now, stop wait", K(ret), K(tenant_id));
}
}
if (OB_FAIL(ret)) {
} else if (is_server_stopped()) {
ret = OB_TIMEOUT;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("server is stopping, check whether the ddl task finish successfully or not", K(ret), K(tenant_id), K(task_id));
}
}
SERVER_EVENT_ADD("ddl", "end wait build index finish",
"tenant_id", tenant_id,
"ret", error_message.ret_code_,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"is_tenant_standby", is_tenant_standby);
LOG_INFO("finish wait build index", K(ret), "ddl_event_info", ObDDLEventInfo(), K(error_message));
return ret;
}
int ObDDLExecutorUtil::wait_ddl_retry_task_finish(
const uint64_t tenant_id,
const int64_t task_id,
ObSQLSessionInfo &session,
obrpc::ObCommonRpcProxy *common_rpc_proxy,
int64_t &affected_rows)
{
int ret = OB_SUCCESS;
affected_rows = 0;
const int64_t retry_interval = 100 * 1000;
ObAddr unused_addr;
bool is_table_exist = false;
int64_t forward_user_msg_len = 0;
THIS_WORKER.set_timeout_ts(ObTimeUtility::current_time() + OB_MAX_USER_SPECIFIED_TIMEOUT);
ObDDLErrorMessageTableOperator::ObBuildDDLErrorMessage error_message;
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || task_id <= 0 || nullptr == common_rpc_proxy)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(task_id), KP(common_rpc_proxy));
} else {
SERVER_EVENT_ADD("ddl", "start wait ddl retry task finish",
"tenant_id", tenant_id,
"ret", ret,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"rpc_dest", common_rpc_proxy->get_server());
LOG_INFO("start wait ddl retry task finish", K(task_id), "ddl_event_info", ObDDLEventInfo(), K(error_message));
bool is_tenant_dropped = false;
bool is_tenant_standby = false;
int tmp_ret = OB_SUCCESS;
while (OB_SUCC(ret)) {
if (OB_SUCCESS == ObDDLErrorMessageTableOperator::get_ddl_error_message(
tenant_id, task_id, -1 /* target_object_id */, unused_addr, true /* is_ddl_retry_task */, *GCTX.sql_proxy_, error_message, forward_user_msg_len)) {
// Here, `forward_user_msg_len` is the length of serialized hex user message.
// Forward_user_msg_len is not 0, which means ObRpcResultCode is not empty. Thus, we need to
// forward_user_error/ forward_user_warn/ forward_user_note.
ret = error_message.ret_code_;
if (OB_UNLIKELY(forward_user_msg_len == 0 && OB_SUCCESS != error_message.ret_code_)) {
const char *str_user_error = ob_errpkt_strerror(error_message.ret_code_, lib::is_oracle_mode());
FORWARD_USER_ERROR(error_message.ret_code_, str_user_error);
FLOG_INFO("error code is not succ, but forward user msg is null", K(ret), K(error_message), K(str_user_error));
} else if (forward_user_msg_len > 0) {
int64_t pos = 0;
int tmp_ret = OB_SUCCESS;
obrpc::ObRpcResultCode result_code;
if (OB_SUCCESS != (tmp_ret = result_code.deserialize(error_message.user_message_, forward_user_msg_len, pos))) {
LOG_WARN("deserialize rpc result code failed", K(ret), K(tmp_ret), K(forward_user_msg_len), K(error_message));
} else if (OB_UNLIKELY(OB_SUCCESS != result_code.rcode_)) {
FORWARD_USER_ERROR(result_code.rcode_, result_code.msg_);
} else if (lib::is_oracle_mode()) {
} else {
for (int i = 0; OB_SUCCESS == tmp_ret && i < result_code.warnings_.count(); ++i) {
const common::ObWarningBuffer::WarningItem warning_item = result_code.warnings_.at(i);
if (ObLogger::USER_WARN == warning_item.log_level_) {
FORWARD_USER_WARN(warning_item.code_, warning_item.msg_);
} else if (ObLogger::USER_NOTE == warning_item.log_level_) {
FORWARD_USER_NOTE(warning_item.code_, warning_item.msg_);
} else {
tmp_ret = OB_ERR_UNEXPECTED;
LOG_WARN("unknown log type", K(ret), K(tmp_ret), K(warning_item));
}
}
}
}
break;
} else {
if (OB_FAIL(ret)) {
} else if (OB_TMP_FAIL(GSCHEMASERVICE.check_if_tenant_has_been_dropped(
tenant_id, is_tenant_dropped))) {
LOG_WARN("check if tenant has been dropped failed", K(tmp_ret), K(tenant_id));
} else if (is_tenant_dropped) {
ret = OB_TENANT_HAS_BEEN_DROPPED;
LOG_WARN("tenant has been dropped", K(ret), K(tenant_id));
}
if (OB_FAIL(ret)) {
} else if (OB_TMP_FAIL(ObAllTenantInfoProxy::is_standby_tenant(GCTX.sql_proxy_, tenant_id, is_tenant_standby))) {
LOG_WARN("check is standby tenant failed", K(tmp_ret), K(tenant_id));
} else if (is_tenant_standby) {
ret = OB_STANDBY_READ_ONLY;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("tenant is standby now, stop wait", K(ret), K(tenant_id));
break;
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(handle_session_exception(session))) {
LOG_WARN("session exception happened", K(ret));
if (OB_TMP_FAIL(cancel_ddl_task(tenant_id, common_rpc_proxy))) {
LOG_WARN("cancel ddl task failed", K(tmp_ret));
ret = OB_SUCCESS;
} else {
break;
}
}
if (OB_FAIL(ret)) {
} else if (is_server_stopped()) {
ret = OB_TIMEOUT;
FORWARD_USER_ERROR(ret, "DDL execution status is undecided, please check later if it finishes successfully or not.");
LOG_WARN("server is stopping, check whether the ddl task finish successfully or not", K(ret), K(tenant_id), K(task_id));
} else {
ob_usleep(retry_interval);
}
}
}
affected_rows = error_message.affected_rows_;
SERVER_EVENT_ADD("ddl", "end wait ddl retry task finish",
"tenant_id", tenant_id,
"ret", error_message.ret_code_,
"trace_id", *ObCurTraceId::get_trace_id(),
"task_id", task_id,
"rpc_dest", common_rpc_proxy->get_server());
LOG_INFO("fnish wait ddl retry task", K(ret), K(task_id), "ddl_event_info", ObDDLEventInfo(), K(error_message));
}
return ret;
}
int ObDDLExecutorUtil::cancel_ddl_task(const int64_t tenant_id, obrpc::ObCommonRpcProxy *common_rpc_proxy)
{
int ret = OB_SUCCESS;
obrpc::ObCancelTaskArg rpc_arg;
rpc_arg.task_id_ = *ObCurTraceId::get_trace_id();
ObAddr rs_leader_addr;
if (OB_FAIL(GCTX.rs_mgr_->get_master_root_server(rs_leader_addr))) {
LOG_WARN("fail to get rootservice address", K(ret));
} else if (OB_FAIL(GCTX.srv_rpc_proxy_->to(rs_leader_addr).cancel_sys_task(rpc_arg))) {
if (OB_ENTRY_NOT_EXIST == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("failed to cancel remote sys task", K(ret), K(rpc_arg), K(rs_leader_addr));
}
}
SERVER_EVENT_ADD("ddl", "finish cancel ddl task",
"tenant_id", tenant_id,
"ret", ret,
"trace_id", *ObCurTraceId::get_trace_id(),
"rpc_dest", rs_leader_addr);
LOG_INFO("finish cancel ddl task", K(ret), K(rpc_arg), K(rs_leader_addr), "ddl_event_info", ObDDLEventInfo());
return ret;
}
} //end namespace sql
} //end namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink