hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Drop/truncate part/table/db without ddl retry task

Browse Source
This commit is contained in:
Hongqin-Li 2023-08-08 04:48:26 +00:00 committed by ob-robot
parent ca5f363b3d
commit 51bb12a3f6
10 changed files with 8 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/rootserver/ddl_task/ob_ddl_scheduler.cpp
View File

@ -973,20 +973,7 @@ int ObDDLScheduler::create_ddl_task(const ObCreateDDLTaskParam &param,
case DDL_DROP_PARTITION:
case DDL_DROP_SUB_PARTITION:
case DDL_TRUNCATE_PARTITION:
case DDL_TRUNCATE_SUB_PARTITION: {
if (OB_FAIL(create_ddl_retry_task(proxy,
param.tenant_id_,
param.object_id_,
param.schema_version_,
param.consumer_group_id_,
param.type_,
param.ddl_arg_,
*param.allocator_,
task_record))) {
LOG_WARN("fail to create ddl retry task", K(ret));
}
break;
}
case DDL_TRUNCATE_SUB_PARTITION:
default:
ret = OB_NOT_SUPPORTED;
LOG_WARN("error unexpected, ddl type is not supported", K(ret), K(param.type_));

23
src/rootserver/ob_ddl_service.cpp
View File

@ -4847,6 +4847,7 @@ int ObDDLService::lock_tablets(ObMySQLTransaction &trans,
timeout,
conn))) {
LOG_WARN("lock dest table failed", KR(ret), K(table_id), K(tenant_id));
ret = ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_EAGAIN : ret;
}
}
}
@ -4878,6 +4879,7 @@ int ObDDLService::lock_table(ObMySQLTransaction &trans,
timeout,
conn))) {
LOG_WARN("lock dest table failed", KR(ret), K(table_schema));
ret = ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_EAGAIN : ret;
}
}
return ret;
@ -4909,7 +4911,6 @@ int ObDDLService::lock_tables_of_database(const ObDatabaseSchema &database_schem
K(table_schema->get_table_id()), K(ret));
} else if (OB_FAIL(lock_table(trans, *table_schema))) {
LOG_WARN("fail to lock_table", KR(ret), KPC(table_schema));
ret = ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_EAGAIN : ret;
}
}
}
@ -4948,7 +4949,6 @@ int ObDDLService::lock_tables_in_recyclebin(const ObDatabaseSchema &database_sch
to_cstring(recycle_obj.get_object_name()));
} else if (OB_FAIL(lock_table(trans, *table_schema))) {
LOG_WARN("fail to lock_table", KR(ret), KPC(table_schema));
ret = ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_EAGAIN : ret;
}
}
}
@ -9980,9 +9980,6 @@ int ObDDLService::alter_table_partitions(const obrpc::ObAlterTableArg &alter_tab
KR(ret), K(orig_table_schema), K(inc_table_schema));
} else if (OB_FAIL(lock_partitions(trans, inc_table_schema))) {
LOG_WARN("failed to get tablet ids", KR(ret), K(orig_table_schema), K(inc_table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = alter_table_arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
} else if (OB_FAIL(ddl_operator.drop_table_partitions(orig_table_schema,
inc_table_schema,
new_table_schema,
@ -9998,9 +9995,6 @@ int ObDDLService::alter_table_partitions(const obrpc::ObAlterTableArg &alter_tab
KR(ret), K(orig_table_schema), K(inc_table_schema));
} else if (OB_FAIL(lock_partitions(trans, inc_table_schema))) {
LOG_WARN("failed to get tablet ids", KR(ret), K(orig_table_schema), K(inc_table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = alter_table_arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
} else if (OB_FAIL(ddl_operator.drop_table_subpartitions(orig_table_schema,
inc_table_schema,
new_table_schema,
@ -10013,9 +10007,6 @@ int ObDDLService::alter_table_partitions(const obrpc::ObAlterTableArg &alter_tab
LOG_WARN("fail to generate inc table schema", KR(ret), K(orig_table_schema));
} else if (OB_FAIL(lock_partitions(trans, del_table_schema))) {
LOG_WARN("failed to get tablet ids", KR(ret), K(orig_table_schema), K(del_table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = alter_table_arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
} else if (OB_FAIL(generate_object_id_for_partition_schema(inc_table_schema))) {
LOG_WARN("fail to generate object_id for partition schema", KR(ret), K(inc_table_schema));
} else if (OB_FAIL(generate_tablet_id(inc_table_schema))) {
@ -10032,9 +10023,6 @@ int ObDDLService::alter_table_partitions(const obrpc::ObAlterTableArg &alter_tab
LOG_WARN("fail to generate inc table schema", KR(ret), K(orig_table_schema));
} else if (OB_FAIL(lock_partitions(trans, del_table_schema))) {
LOG_WARN("failed to get tablet ids", KR(ret), K(orig_table_schema), K(del_table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = alter_table_arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
} else if (OB_FAIL(generate_object_id_for_partition_schema(inc_table_schema, true))) {
LOG_WARN("fail to generate object_id for partition schema", KR(ret), K(inc_table_schema));
} else if (OB_FAIL(generate_tablet_id(inc_table_schema))) {
@ -17400,9 +17388,6 @@ int ObDDLService::truncate_table(const ObTruncateTableArg &arg,
if (OB_FAIL(ret)) {
} else if (OB_FAIL(lock_table(trans, *orig_table_schema))) {
LOG_WARN("fail to lock_table", KR(ret), KPC(orig_table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
}
if (OB_SUCC(ret) && orig_table_schema->is_oracle_tmp_table()) {
@ -19063,7 +19048,6 @@ int ObDDLService::purge_table(
LOG_WARN("start transaction failed", KR(ret), K(tenant_id), K(refreshed_schema_version));
} else if (OB_FAIL(lock_table(OB_ISNULL(pr_trans) ? trans : *pr_trans, *table_schema))) {
LOG_WARN("fail to lock_table", KR(ret), KPC(table_schema));
ret = ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_EAGAIN : ret;
} else if (OB_FAIL(ddl_operator.purge_table_with_aux_table(*table_schema,
schema_guard,
OB_ISNULL(pr_trans) ? trans : *pr_trans,
@ -19883,9 +19867,6 @@ int ObDDLService::drop_table(const ObDropTableArg &drop_table_arg, const obrpc::
LOG_WARN("set table_id to hash set failed", K(table_schema->get_table_id()), K(ret));
} else if (OB_FAIL(lock_table(trans, *table_schema))) {
LOG_WARN("fail to lock_table", KR(ret), KPC(table_schema));
// for ddl retry task, upper layer only focus on `OB_TRY_LOCK_ROW_CONFLICT`, and then retry it.
const bool is_ddl_scheduled_task = drop_table_arg.task_id_ > 0 ? true : false;
ret = is_ddl_scheduled_task && ObDDLUtil::is_table_lock_retry_ret_code(ret) ? OB_TRY_LOCK_ROW_CONFLICT : ret;
}
}
}

18
src/sql/engine/cmd/ob_database_executor.cpp
View File

@ -188,6 +188,7 @@ int ObDropDatabaseExecutor::execute(ObExecContext &ctx, ObDropDatabaseStmt &stmt
const obrpc::ObDropDatabaseArg &drop_database_arg = stmt.get_drop_database_arg();
obrpc::ObDropDatabaseArg &tmp_arg = const_cast<obrpc::ObDropDatabaseArg&>(drop_database_arg);
ObString first_stmt;
uint64_t database_id = 0;
if (OB_FAIL(stmt.get_first_stmt(first_stmt))) {
SQL_ENG_LOG(WARN, "fail to get first stmt" , K(ret));
} else {
@ -229,25 +230,12 @@ int ObDropDatabaseExecutor::execute(ObExecContext &ctx, ObDropDatabaseStmt &stmt
} else if (OB_FAIL(ctx.get_my_session()->set_default_database(null_string, server_coll_type))) {
SQL_ENG_LOG(WARN, "fail to set default database", K(ret), K(stmt.get_server_collation()), K(server_coll_type));
} else {
ctx.get_physical_plan_ctx()->set_affected_rows(drop_database_res.affected_row_);
ctx.get_my_session()->set_database_id(OB_INVALID_ID);
}
}
}
if (OB_SUCC(ret) && drop_database_res.is_valid()) {
int64_t affected_rows = 0;
ObSQLSessionInfo *my_session = nullptr;
if (OB_ISNULL(my_session = ctx.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
SQL_ENG_LOG(WARN, "my_session is nullptr", K(ret));
} else if (drop_database_res.is_valid() &&
OB_FAIL(ObDDLExecutorUtil::wait_ddl_retry_task_finish(drop_database_res.ddl_res_.tenant_id_,
drop_database_res.ddl_res_.task_id_,
*my_session, common_rpc_proxy, affected_rows))) {
SQL_ENG_LOG(WARN, "wait ddl finish failed", K(ret));
} else {
ctx.get_physical_plan_ctx()->set_affected_rows(affected_rows);
}
if (OB_SUCC(ret)) {
ctx.get_physical_plan_ctx()->set_affected_rows(drop_database_res.affected_row_);
}
}
SQL_ENG_LOG(INFO, "finish execute drop database.", K(ret), K(stmt));

10
src/sql/engine/cmd/ob_table_executor.cpp
View File

@ -1231,21 +1231,15 @@ int ObAlterTableExecutor::execute(ObExecContext &ctx, ObAlterTableStmt &stmt)
}
if (OB_SUCC(ret)) {
const bool is_ddl_retry_task = is_drop_schema_block_concurrent_trans(res.ddl_type_);
const bool need_wait_ddl_finish = is_double_table_long_running_ddl(res.ddl_type_)
|| is_simple_table_long_running_ddl(res.ddl_type_)
|| is_ddl_retry_task;
|| is_simple_table_long_running_ddl(res.ddl_type_);
if (OB_SUCC(ret) && need_wait_ddl_finish) {
int64_t affected_rows = 0;
if (OB_FAIL(refresh_schema_for_table(alter_table_arg.exec_tenant_id_))) {
LOG_WARN("refresh_schema_for_table failed", K(ret));
} else if (!is_ddl_retry_task && OB_FAIL(ObDDLExecutorUtil::wait_ddl_finish(tenant_id, res.task_id_,
} else if (OB_FAIL(ObDDLExecutorUtil::wait_ddl_finish(tenant_id, res.task_id_,
*my_session, common_rpc_proxy))) {
LOG_WARN("fail to wait ddl finish", K(ret), K(tenant_id), K(res));
} else if (is_ddl_retry_task && OB_FAIL(ObDDLExecutorUtil::wait_ddl_retry_task_finish(tenant_id, res.task_id_,
*my_session, common_rpc_proxy,
affected_rows))) {
LOG_WARN("fail to wait ddl retry task finish", K(ret), K(tenant_id), K(res));
}
}
}

4
src/sql/resolver/ddl/ob_alter_table_resolver.cpp
View File

@ -3757,7 +3757,6 @@ int ObAlterTableResolver::resolve_partition_options(const ParseNode &node)
} else {
alter_table_stmt->get_alter_table_arg().is_update_global_indexes_ = partition_node->num_child_ == 2;
alter_table_stmt->get_alter_table_arg().alter_part_type_ = ObAlterTableArg::DROP_PARTITION;
alter_table_stmt->get_alter_table_arg().is_add_to_scheduler_ = true;
}
break;
}
@ -3767,7 +3766,6 @@ int ObAlterTableResolver::resolve_partition_options(const ParseNode &node)
} else {
alter_table_stmt->get_alter_table_arg().is_update_global_indexes_ = partition_node->num_child_ == 2;
alter_table_stmt->get_alter_table_arg().alter_part_type_ = ObAlterTableArg::DROP_SUB_PARTITION;
alter_table_stmt->get_alter_table_arg().is_add_to_scheduler_ = true;
}
break;
}
@ -3842,7 +3840,6 @@ int ObAlterTableResolver::resolve_partition_options(const ParseNode &node)
} else {
alter_table_stmt->get_alter_table_arg().is_update_global_indexes_ = partition_node->num_child_ == 2;
alter_table_stmt->get_alter_table_arg().alter_part_type_ = ObAlterTableArg::TRUNCATE_PARTITION;
alter_table_stmt->get_alter_table_arg().is_add_to_scheduler_ = true;
}
break;
}
@ -3852,7 +3849,6 @@ int ObAlterTableResolver::resolve_partition_options(const ParseNode &node)
} else {
alter_table_stmt->get_alter_table_arg().is_update_global_indexes_ = partition_node->num_child_ == 2;
alter_table_stmt->get_alter_table_arg().alter_part_type_ = ObAlterTableArg::TRUNCATE_SUB_PARTITION;
alter_table_stmt->get_alter_table_arg().is_add_to_scheduler_ = true;
}
break;
}

1
src/sql/resolver/ddl/ob_drop_database_resolver.cpp
View File

@ -56,7 +56,6 @@ int ObDropDatabaseResolver::resolve(const ParseNode &parse_tree)
LOG_ERROR("failed to create drop_database_stmt", K(ret));
} else {
stmt_ = drop_database_stmt;
drop_database_stmt->set_is_add_to_scheduler(true);
drop_database_stmt->set_tenant_id(session_info_->get_effective_tenant_id());
}
//resolve if exist

4
src/sql/resolver/ddl/ob_drop_database_stmt.h
View File

@ -44,10 +44,6 @@ public:
{
drop_database_arg_.tenant_id_ = tenant_id;
}
void set_is_add_to_scheduler(const bool is_add_to_scheduler)
{
drop_database_arg_.is_add_to_scheduler_ = is_add_to_scheduler;
}
void set_if_exist(const bool if_exist)
{

1
src/sql/resolver/ddl/ob_drop_table_resolver.cpp
View File

@ -61,7 +61,6 @@ int ObDropTableResolver::resolve(const ParseNode &parse_tree)
} else {
drop_table_arg.if_exist_ = (NULL != parse_tree.children_[IF_EXIST_NODE]) ? true : false;
}
drop_table_arg.is_add_to_scheduler_ = true;
drop_table_arg.tenant_id_ = session_info_->get_effective_tenant_id();
drop_table_arg.to_recyclebin_ = is_recyclebin_open.get_bool();
}

2
src/sql/resolver/ddl/ob_truncate_table_resolver.cpp
View File

@ -124,8 +124,6 @@ int ObTruncateTableResolver::resolve(const ParseNode &parser_tree)
to_cstring(truncate_table_stmt->get_table_name()));
}
} else {
const bool is_add_to_scheduler = orig_table_schema->is_user_table() ? true : false;
truncate_table_stmt->set_is_add_scheduler(is_add_to_scheduler);
if (orig_table_schema->is_oracle_tmp_table()) {
truncate_table_stmt->set_truncate_oracle_temp_table();
truncate_table_stmt->set_oracle_temp_table_type(orig_table_schema->get_table_type());

2
src/sql/resolver/ddl/ob_truncate_table_stmt.h
View File

@ -34,8 +34,6 @@ public:
uint64_t get_tenant_id() const { return truncate_table_arg_.tenant_id_; }
const common::ObString& get_database_name() const { return truncate_table_arg_.database_name_; }
const common::ObString& get_table_name() const { return truncate_table_arg_.table_name_; }
void set_is_add_scheduler(bool is_add_to_scheduler)
{ truncate_table_arg_.is_add_to_scheduler_ = is_add_to_scheduler; }
inline const obrpc::ObTruncateTableArg &get_truncate_table_arg() const;
obrpc::ObTruncateTableArg &get_truncate_table_arg() { return truncate_table_arg_; }