init push
This commit is contained in:
oceanbase-admin
377
src/sql/engine/cmd/ob_index_executor.cpp
Normal file
377
src/sql/engine/cmd/ob_index_executor.cpp
Normal file
@ -0,0 +1,377 @@
|
||||
/**
|
||||
* 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_index_executor.h"
|
||||
|
||||
#include "share/ob_common_rpc_proxy.h"
|
||||
#include "share/system_variable/ob_system_variable_alias.h"
|
||||
#include "share/schema/ob_table_schema.h"
|
||||
#include "sql/resolver/ddl/ob_create_index_stmt.h"
|
||||
#include "sql/resolver/ddl/ob_drop_index_stmt.h"
|
||||
#include "sql/resolver/ddl/ob_purge_stmt.h"
|
||||
#include "sql/resolver/ob_resolver_utils.h"
|
||||
#include "sql/engine/ob_exec_context.h"
|
||||
#include "sql/engine/cmd/ob_partition_executor_utils.h"
|
||||
#include "observer/ob_server.h"
|
||||
|
||||
using namespace oceanbase::common;
|
||||
namespace oceanbase {
|
||||
using namespace oceanbase::share::schema;
|
||||
|
||||
namespace sql {
|
||||
|
||||
ObCreateIndexExecutor::ObCreateIndexExecutor()
|
||||
{}
|
||||
|
||||
ObCreateIndexExecutor::~ObCreateIndexExecutor()
|
||||
{}
|
||||
|
||||
int ObCreateIndexExecutor::execute(ObExecContext& ctx, ObCreateIndexStmt& stmt)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObTaskExecutorCtx* task_exec_ctx = NULL;
|
||||
obrpc::ObCommonRpcProxy* common_rpc_proxy = NULL;
|
||||
obrpc::ObCreateIndexArg& create_index_arg = stmt.get_create_index_arg();
|
||||
ObSQLSessionInfo* my_session = ctx.get_my_session();
|
||||
const bool is_sys_index = is_inner_table(create_index_arg.index_table_id_);
|
||||
obrpc::ObAlterTableRes res;
|
||||
ObString first_stmt;
|
||||
bool is_sync_ddl_user = false;
|
||||
ObArenaAllocator allocator(ObModIds::OB_SQL_EXECUTOR);
|
||||
|
||||
if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
|
||||
LOG_WARN("fail to get first stmt", K(ret));
|
||||
} else {
|
||||
create_index_arg.ddl_stmt_str_ = first_stmt;
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (NULL == my_session) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("failed to get my session", K(ret), K(ctx));
|
||||
} else if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("get task executor context failed");
|
||||
} else if (OB_FAIL(ObPartitionExecutorUtils::calc_values_exprs(ctx, stmt))) {
|
||||
LOG_WARN("fail to compare range partition expr", K(ret));
|
||||
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
|
||||
LOG_WARN("get common rpc proxy failed", K(ret));
|
||||
} else if (OB_ISNULL(common_rpc_proxy)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("common rpc proxy should not be null", K(ret));
|
||||
} else if (OB_INVALID_ID == create_index_arg.session_id_ &&
|
||||
FALSE_IT(create_index_arg.session_id_ = my_session->get_sessid_for_table())) {
|
||||
// impossible
|
||||
} else if (FALSE_IT(create_index_arg.is_inner_ = my_session->is_inner())) {
|
||||
} else if (OB_FAIL(common_rpc_proxy->create_index(create_index_arg, res))) {
|
||||
LOG_WARN("rpc proxy create index failed", K(create_index_arg), "dst", common_rpc_proxy->get_server(), K(ret));
|
||||
} else if (OB_FAIL(ObResolverUtils::check_sync_ddl_user(my_session, is_sync_ddl_user))) {
|
||||
LOG_WARN("Failed to check sync_dll_user", K(ret));
|
||||
} else if (!is_sys_index && !is_sync_ddl_user) {
|
||||
// only check sync index status for non-sys table and when it's not backup or restore
|
||||
create_index_arg.index_schema_.set_table_id(res.index_table_id_);
|
||||
create_index_arg.index_schema_.set_schema_version(res.schema_version_);
|
||||
if (OB_FAIL(sync_check_index_status(*my_session, *common_rpc_proxy, create_index_arg, allocator))) {
|
||||
LOG_WARN("failed to sync_check_index_status", K(create_index_arg), K(ret));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObCreateIndexExecutor::set_drop_index_stmt_str(
|
||||
obrpc::ObDropIndexArg& drop_index_arg, common::ObIAllocator& allocator)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
char* buf = NULL;
|
||||
int64_t buf_len = OB_MAX_SQL_LENGTH;
|
||||
int64_t pos = 0;
|
||||
|
||||
if (OB_ISNULL(buf = static_cast<char*>(allocator.alloc(buf_len)))) {
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
LOG_WARN("fail to allocate memory", K(ret), K(OB_MAX_SQL_LENGTH));
|
||||
} else if (is_mysql_mode() && OB_FAIL(databuff_printf(buf,
|
||||
buf_len,
|
||||
pos,
|
||||
"ALTER TABLE `%.*s`.`%.*s` DROP INDEX `%.*s`",
|
||||
drop_index_arg.database_name_.length(),
|
||||
drop_index_arg.database_name_.ptr(),
|
||||
drop_index_arg.table_name_.length(),
|
||||
drop_index_arg.table_name_.ptr(),
|
||||
drop_index_arg.index_name_.length(),
|
||||
drop_index_arg.index_name_.ptr()))) {
|
||||
LOG_WARN("fail to print ddl_stmt_str for rollback", K(ret));
|
||||
} else if (is_oracle_mode() && OB_FAIL(databuff_printf(buf,
|
||||
buf_len,
|
||||
pos,
|
||||
"DROP INDEX \"%.*s\"",
|
||||
drop_index_arg.index_name_.length(),
|
||||
drop_index_arg.index_name_.ptr()))) {
|
||||
LOG_WARN("fail to print ddl_stmt_str for rollback", K(ret));
|
||||
} else {
|
||||
drop_index_arg.ddl_stmt_str_.assign_ptr(buf, static_cast<int32_t>(pos));
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// is_update_global_indexes = true: creating index caused by drop/truncate partition,don't need to drop failed index
|
||||
// when reports error. is_update_global_indexes = false:creating index caused by create index/alter table add index,need
|
||||
// to drop failed index when reports error.
|
||||
int ObCreateIndexExecutor::sync_check_index_status(sql::ObSQLSessionInfo& my_session,
|
||||
obrpc::ObCommonRpcProxy& common_rpc_proxy, const obrpc::ObCreateIndexArg& create_index_arg,
|
||||
common::ObIAllocator& allocator, bool is_update_global_indexes)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
// force refresh schema version, make sure version of observer is latest
|
||||
THIS_WORKER.set_timeout_ts(ObTimeUtility::current_time() + OB_MAX_USER_SPECIFIED_TIMEOUT);
|
||||
bool is_finish = false;
|
||||
const static int CHECK_INTERVAL = 100 * 1000; // 100ms
|
||||
obrpc::ObDropIndexArg drop_index_arg;
|
||||
int64_t refreshed_schema_version = OB_INVALID_VERSION;
|
||||
const uint64_t tenant_id = my_session.get_effective_tenant_id();
|
||||
const uint64_t index_table_id = create_index_arg.index_schema_.get_table_id();
|
||||
ObSqlString drop_index_sql;
|
||||
|
||||
if (!is_update_global_indexes) {
|
||||
if (share::is_oracle_mode()) {
|
||||
ret = drop_index_sql.append_fmt(
|
||||
"drop index \"%.*s\"", create_index_arg.index_name_.length(), create_index_arg.index_name_.ptr());
|
||||
} else {
|
||||
ret = drop_index_sql.append_fmt("drop index `%.*s` on `%.*s`",
|
||||
create_index_arg.index_name_.length(),
|
||||
create_index_arg.index_name_.ptr(),
|
||||
create_index_arg.table_name_.length(),
|
||||
create_index_arg.table_name_.ptr());
|
||||
}
|
||||
if (!OB_SUCC(ret)) {
|
||||
OB_LOG(WARN, "fail to append drop index sql", KR(ret));
|
||||
} else {
|
||||
drop_index_arg.tenant_id_ = create_index_arg.tenant_id_;
|
||||
drop_index_arg.exec_tenant_id_ = create_index_arg.tenant_id_;
|
||||
drop_index_arg.index_table_id_ = index_table_id;
|
||||
drop_index_arg.session_id_ = create_index_arg.session_id_;
|
||||
drop_index_arg.index_name_ = create_index_arg.index_name_;
|
||||
drop_index_arg.table_name_ = create_index_arg.table_name_;
|
||||
drop_index_arg.database_name_ = create_index_arg.database_name_;
|
||||
drop_index_arg.index_action_type_ = obrpc::ObIndexArg::DROP_INDEX;
|
||||
drop_index_arg.to_recyclebin_ = false;
|
||||
drop_index_arg.ddl_stmt_str_ = drop_index_sql.string();
|
||||
}
|
||||
}
|
||||
|
||||
while (OB_SUCC(ret) && !is_finish) {
|
||||
// check whether index_table_id received from rs is valid.
|
||||
if (OB_UNLIKELY(OB_INVALID_ID == index_table_id)) {
|
||||
is_finish = true;
|
||||
if (true == create_index_arg.if_not_exist_) {
|
||||
// if not exist, ignore error code and exit check_index_status
|
||||
// since the index is not created, don't need to rollback.
|
||||
break;
|
||||
} else {
|
||||
ret = OB_ERR_ADD_INDEX;
|
||||
LOG_WARN("index table id is invalid", KR(ret), K(index_table_id));
|
||||
}
|
||||
}
|
||||
// handle session timeout or killed first.
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_FAIL(handle_session_exception(my_session))) {
|
||||
if (!is_update_global_indexes && (OB_ERR_QUERY_INTERRUPTED == ret || OB_SESSION_KILLED == ret)) {
|
||||
LOG_WARN("handle_session_exception", KR(ret));
|
||||
int tmp_ret = OB_SUCCESS;
|
||||
if (OB_SUCCESS != (tmp_ret = common_rpc_proxy.drop_index(drop_index_arg))) {
|
||||
LOG_WARN("rpc proxy drop index failed",
|
||||
"dst",
|
||||
common_rpc_proxy.get_server(),
|
||||
K(tmp_ret),
|
||||
K(drop_index_arg.table_name_),
|
||||
K(drop_index_arg.index_name_));
|
||||
}
|
||||
} else {
|
||||
LOG_WARN("failed to handle_session_exception", KR(ret));
|
||||
}
|
||||
}
|
||||
|
||||
// If switch to standby db when it start to work,
|
||||
// return session killed, and the index is handled by standby.
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_SYS_TENANT_ID == tenant_id) {
|
||||
// no need to process sys tenant
|
||||
} else if (OB_FAIL(handle_switchover())) {
|
||||
if (OB_SESSION_KILLED != ret) {
|
||||
LOG_WARN("fail to handle switchover status", KR(ret));
|
||||
} else {
|
||||
LOG_WARN("fail to add index while swithover", KR(ret));
|
||||
}
|
||||
}
|
||||
|
||||
share::schema::ObMultiVersionSchemaService* schema_service = GCTX.schema_service_;
|
||||
const ObTableSchema* index_schema = NULL;
|
||||
share::schema::ObSchemaGetterGuard schema_guard;
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (NULL == schema_service) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("failed to get schema servicie", KR(ret));
|
||||
} else if (OB_FAIL(schema_service->get_tenant_refreshed_schema_version(tenant_id, refreshed_schema_version))) {
|
||||
LOG_WARN("fail to get tenant refreshed schema version", KR(ret), K(tenant_id), K(refreshed_schema_version));
|
||||
} else if (refreshed_schema_version < create_index_arg.index_schema_.get_schema_version()) {
|
||||
// not refresh schema after the index is created, check again after sleep
|
||||
usleep(CHECK_INTERVAL);
|
||||
LOG_INFO("we have not gotten the index schema",
|
||||
K(index_table_id),
|
||||
K(refreshed_schema_version),
|
||||
K(create_index_arg.index_schema_.get_schema_version()));
|
||||
} else if (OB_FAIL(schema_service->get_tenant_schema_guard(tenant_id, schema_guard))) {
|
||||
LOG_WARN("get schema guard failed", KR(ret), K(refreshed_schema_version));
|
||||
} else if (OB_FAIL(schema_guard.get_table_schema(index_table_id, index_schema))) {
|
||||
LOG_WARN("fail to get index table schema", KR(ret), K(refreshed_schema_version), K(index_table_id));
|
||||
} else if (OB_ISNULL(index_schema)) {
|
||||
// maybe ddl(drop index,drop table,truncate table) in another session has dropped this index.
|
||||
if (!is_update_global_indexes) {
|
||||
ret = OB_ERR_ADD_INDEX;
|
||||
LOG_USER_ERROR(OB_ERR_ADD_INDEX);
|
||||
} else {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
}
|
||||
LOG_WARN("index table schema is null",
|
||||
KR(ret),
|
||||
K(index_table_id),
|
||||
K(refreshed_schema_version),
|
||||
K(create_index_arg.index_schema_.get_schema_version()));
|
||||
} else if (!is_final_index_status(index_schema->get_index_status(), index_schema->is_dropped_schema())) {
|
||||
usleep(CHECK_INTERVAL);
|
||||
LOG_INFO("index status is not final", K(index_table_id));
|
||||
} else {
|
||||
is_finish = true;
|
||||
LOG_INFO("index status is final", K(index_table_id), K(index_schema->get_index_status()));
|
||||
if (is_error_index_status(index_schema->get_index_status(), index_schema->is_dropped_schema())) {
|
||||
// status of index is ERROR, need to rollback.
|
||||
if (is_update_global_indexes) {
|
||||
ret = OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX;
|
||||
LOG_USER_ERROR(OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX,
|
||||
create_index_arg.index_name_.length(),
|
||||
create_index_arg.index_name_.ptr());
|
||||
} else {
|
||||
ret = OB_ERR_ADD_INDEX;
|
||||
LOG_USER_ERROR(OB_ERR_ADD_INDEX);
|
||||
int tmp_ret = OB_SUCCESS;
|
||||
if (OB_SUCCESS != (tmp_ret = set_drop_index_stmt_str(drop_index_arg, allocator))) {
|
||||
LOG_WARN("fail to set drop index ddl_stmt_str", K(tmp_ret));
|
||||
} else if (OB_SUCCESS != (tmp_ret = common_rpc_proxy.drop_index(drop_index_arg))) {
|
||||
LOG_WARN("rpc proxy drop index failed",
|
||||
"dst",
|
||||
common_rpc_proxy.get_server(),
|
||||
K(tmp_ret),
|
||||
K(drop_index_arg.table_name_),
|
||||
K(drop_index_arg.index_name_));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObCreateIndexExecutor::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));
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObCreateIndexExecutor::handle_switchover()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (GCTX.is_standby_cluster()) {
|
||||
ret = OB_SESSION_KILLED;
|
||||
LOG_INFO("create index while switchoverd, kill session", KR(ret));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
ObDropIndexExecutor::ObDropIndexExecutor()
|
||||
{}
|
||||
|
||||
ObDropIndexExecutor::~ObDropIndexExecutor()
|
||||
{}
|
||||
|
||||
int ObDropIndexExecutor::execute(ObExecContext& ctx, ObDropIndexStmt& stmt)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObTaskExecutorCtx* task_exec_ctx = NULL;
|
||||
obrpc::ObCommonRpcProxy* common_rpc_proxy = NULL;
|
||||
const obrpc::ObDropIndexArg& drop_index_arg = stmt.get_drop_index_arg();
|
||||
ObSQLSessionInfo* my_session = ctx.get_my_session();
|
||||
ObString first_stmt;
|
||||
if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
|
||||
LOG_WARN("fail to get first stmt", K(ret));
|
||||
} else {
|
||||
const_cast<obrpc::ObDropIndexArg&>(drop_index_arg).ddl_stmt_str_ = first_stmt;
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (NULL == my_session) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("failed to get my session", K(ret), K(ctx));
|
||||
} else if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("get task executor context failed");
|
||||
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
|
||||
LOG_WARN("get common rpc proxy failed", K(ret));
|
||||
} else if (OB_ISNULL(common_rpc_proxy)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("common rpc proxy should not be null", K(ret));
|
||||
} else if (OB_INVALID_ID == drop_index_arg.session_id_ &&
|
||||
FALSE_IT(
|
||||
const_cast<obrpc::ObDropIndexArg&>(drop_index_arg).session_id_ = my_session->get_sessid_for_table())) {
|
||||
// impossible
|
||||
} else if (OB_FAIL(common_rpc_proxy->drop_index(drop_index_arg))) {
|
||||
LOG_WARN("rpc proxy drop index failed", "dst", common_rpc_proxy->get_server(), K(ret));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObPurgeIndexExecutor::execute(ObExecContext& ctx, ObPurgeIndexStmt& stmt)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObTaskExecutorCtx* task_exec_ctx = NULL;
|
||||
obrpc::ObCommonRpcProxy* common_rpc_proxy = NULL;
|
||||
const obrpc::ObPurgeIndexArg& purge_index_arg = stmt.get_purge_index_arg();
|
||||
ObString first_stmt;
|
||||
if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
|
||||
LOG_WARN("fail to get first stmt", K(ret));
|
||||
} else {
|
||||
const_cast<obrpc::ObPurgeIndexArg&>(purge_index_arg).ddl_stmt_str_ = first_stmt;
|
||||
}
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_ISNULL(task_exec_ctx = GET_TASK_EXECUTOR_CTX(ctx))) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("get task executor context failed");
|
||||
} else if (OB_FAIL(task_exec_ctx->get_common_rpc(common_rpc_proxy))) {
|
||||
LOG_WARN("get common rpc proxy failed", K(ret));
|
||||
} else if (OB_ISNULL(common_rpc_proxy)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("common rpc proxy should not be null", K(ret));
|
||||
} else if (OB_FAIL(common_rpc_proxy->purge_index(purge_index_arg))) {
|
||||
LOG_WARN("rpc proxy purge index failed", "dst", common_rpc_proxy->get_server(), K(ret));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace sql
|
||||
} // namespace oceanbase
|
||||
Reference in New Issue
Block a user