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

Do not report ERROR when sample rate equals 100

Browse Source
This commit is contained in:
ZenoWang
2024-02-06 14:49:31 +00:00
committed by ob-robot
parent 1f1d5c08ae
commit c8ef409bf3
3710 changed files with 486984 additions and 3083329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
src/rootserver/ddl_task/ob_table_redefinition_task.cpp
View File

@ -17,7 +17,6 @@
#include "share/ob_ddl_error_message_table_operator.h"
#include "share/ob_autoincrement_service.h"
#include "share/ob_ddl_checksum.h"
#include "share/ob_ddl_sim_point.h"
#include "rootserver/ddl_task/ob_ddl_scheduler.h"
#include "rootserver/ob_root_service.h"
#include "rootserver/ddl_task/ob_ddl_redefinition_task.h"
@ -39,7 +38,7 @@ ObTableRedefinitionTask::ObTableRedefinitionTask()
has_rebuild_index_(false), has_rebuild_constraint_(false), has_rebuild_foreign_key_(false),
allocator_(lib::ObLabel("RedefTask")),
is_copy_indexes_(true), is_copy_triggers_(true), is_copy_constraints_(true), is_copy_foreign_keys_(true),
is_ignore_errors_(false), is_do_finish_(false), target_cg_cnt_(0)
is_ignore_errors_(false), is_do_finish_(false)
{
}
@ -47,79 +46,60 @@ ObTableRedefinitionTask::~ObTableRedefinitionTask()
{
}
int ObTableRedefinitionTask::init(const ObTableSchema* src_table_schema,
const ObTableSchema* dst_table_schema,
const int64_t parent_task_id,
const int64_t task_id,
const share::ObDDLType &ddl_type,
const int64_t parallelism,
const int64_t consumer_group_id,
const int32_t sub_task_trace_id,
const ObAlterTableArg &alter_table_arg,
const uint64_t tenant_data_version,
const int64_t task_status,
const int64_t snapshot_version)
int ObTableRedefinitionTask::init(const uint64_t src_tenant_id, const uint64_t dst_tenant_id, const int64_t task_id,
const share::ObDDLType &ddl_type, const int64_t data_table_id, const int64_t dest_table_id, const int64_t src_schema_version,
const int64_t dst_schema_version, const int64_t parallelism, const int64_t consumer_group_id,
const ObAlterTableArg &alter_table_arg, const int64_t task_status, const int64_t snapshot_version)
{
int ret = OB_SUCCESS;
uint64_t tenant_data_format_version = 0;
if (OB_UNLIKELY(is_inited_)) {
ret = OB_INIT_TWICE;
LOG_WARN("ObTableRedefinitionTask has already been inited", K(ret));
} else if (OB_ISNULL(src_table_schema) || OB_ISNULL(dst_table_schema)) {
} else if (OB_UNLIKELY(OB_INVALID_ID == src_tenant_id || OB_INVALID_ID == dst_tenant_id
|| task_id <= 0 || OB_INVALID_ID == data_table_id || OB_INVALID_ID == dest_table_id
|| src_schema_version <= 0 || dst_schema_version <= 0
|| task_status < ObDDLTaskStatus::PREPARE || task_status > ObDDLTaskStatus::SUCCESS || snapshot_version < 0
|| (snapshot_version > 0 && task_status < ObDDLTaskStatus::WAIT_TRANS_END))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), KP(src_table_schema), KP(dst_table_schema));
} else if (OB_UNLIKELY( !src_table_schema->is_valid()
|| !dst_table_schema->is_valid()
|| task_id <= 0 || snapshot_version < 0 || tenant_data_version <= 0
|| task_status < ObDDLTaskStatus::PREPARE || task_status > ObDDLTaskStatus::SUCCESS
|| (snapshot_version > 0 && task_status < ObDDLTaskStatus::WAIT_TRANS_END))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), KPC(src_table_schema), KPC(dst_table_schema), K(task_id),
LOG_WARN("invalid arguments", K(ret), K(src_tenant_id), K(dst_tenant_id), K(task_id),
K(data_table_id), K(dest_table_id), K(src_schema_version), K(dst_schema_version),
K(task_status), K(snapshot_version));
} else if (OB_FAIL(deep_copy_table_arg(allocator_, alter_table_arg, alter_table_arg_))) {
LOG_WARN("deep copy alter table arg failed", K(ret));
} else if (OB_FAIL(set_ddl_stmt_str(alter_table_arg_.ddl_stmt_str_))) {
LOG_WARN("set ddl stmt str failed", K(ret));
} else if (OB_FAIL(ObShareUtil::fetch_current_data_version(*GCTX.sql_proxy_, src_tenant_id, tenant_data_format_version))) {
LOG_WARN("get min data version failed", K(ret), K(src_tenant_id));
} else {
set_gmt_create(ObTimeUtility::current_time());
consumer_group_id_ = consumer_group_id;
sub_task_trace_id_ = sub_task_trace_id;
task_type_ = ddl_type;
object_id_ = src_table_schema->get_table_id();
target_object_id_ = dst_table_schema->get_table_id();
/* only table restore set schema_serson = src, other use dst*/
if (ObDDLType::DDL_TABLE_RESTORE == ddl_type) {
schema_version_ = src_table_schema->get_schema_version();
} else {
schema_version_ = dst_table_schema->get_schema_version();
}
object_id_ = data_table_id;
target_object_id_ = dest_table_id;
schema_version_ = src_schema_version;
task_status_ = static_cast<ObDDLTaskStatus>(task_status);
snapshot_version_ = snapshot_version;
tenant_id_ = src_table_schema->get_tenant_id();
tenant_id_ = src_tenant_id;
task_version_ = OB_TABLE_REDEFINITION_TASK_VERSION;
parent_task_id_ = parent_task_id;
task_id_ = task_id;
parallelism_ = parallelism;
data_format_version_ = tenant_data_version;
data_format_version_ = tenant_data_format_version;
start_time_ = ObTimeUtility::current_time();
// For common offline ddl, dest_tenant_id is also the tenant_id_, i.e., tenant id of the data table.
// But for DDL_RESTORE_TABLE, dst_tenant_id_ is different to the tenant_id_.
dst_tenant_id_ = dst_table_schema->get_tenant_id();
dst_schema_version_ = dst_table_schema->get_schema_version();
alter_table_arg_.alter_table_schema_.set_tenant_id(tenant_id_);
alter_table_arg_.alter_table_schema_.set_schema_version(schema_version_);
dst_tenant_id_ = dst_tenant_id;
dst_schema_version_ = dst_schema_version;
alter_table_arg_.alter_table_schema_.set_tenant_id(src_tenant_id);
alter_table_arg_.alter_table_schema_.set_schema_version(src_schema_version);
alter_table_arg_.exec_tenant_id_ = dst_tenant_id_;
if (OB_FAIL(dst_table_schema->get_store_column_group_count(target_cg_cnt_))) {
LOG_WARN("fail to get target cg cnt", K(ret), KPC(dst_table_schema));
} else if (OB_FAIL(init_ddl_task_monitor_info(target_object_id_))) {
if (OB_FAIL(init_ddl_task_monitor_info(target_object_id_))) {
LOG_WARN("init ddl task monitor info failed", K(ret));
} else {
is_inited_ = true;
ddl_tracing_.open();
}
}
LOG_INFO("init table redefinition task finished", K(ret), KPC(this));
return ret;
}
@ -164,7 +144,6 @@ int ObTableRedefinitionTask::init(const ObDDLTaskRecord &task_record)
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected err", K(ret), K(task_record), K(src_tenant_id), K(dst_tenant_id), K(src_schema_version), K(dst_schema_version));
} else {
parent_task_id_ = task_record.parent_task_id_;
task_id_ = task_record.task_id_;
object_id_ = data_table_id;
target_object_id_ = dest_table_id;
@ -186,7 +165,6 @@ int ObTableRedefinitionTask::init(const ObDDLTaskRecord &task_record)
ddl_tracing_.open_for_recovery();
}
}
LOG_INFO("init table redefinition task finished", K(ret), KPC(this));
return ret;
}
@ -204,8 +182,6 @@ int ObTableRedefinitionTask::update_complete_sstable_job_status(const common::Ob
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("ObTableRedefinitionTask has not been inited", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, UPDATE_COMPLETE_SSTABLE_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else if (ObDDLTaskStatus::CHECK_TABLE_EMPTY == task_status_) {
check_table_empty_job_ret_code_ = ret_code;
} else {
@ -265,8 +241,6 @@ int ObTableRedefinitionTask::send_build_replica_request_by_sql()
if (OB_ISNULL(root_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("error unexpected, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, DDL_TASK_SEND_BUILD_REPLICA_REQUEST_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else if (OB_FAIL(check_modify_autoinc(modify_autoinc))) {
LOG_WARN("failed to check modify autoinc", K(ret));
} else if (OB_FAIL(check_use_heap_table_ddl_plan(use_heap_table_ddl_plan))) {
@ -287,7 +261,6 @@ int ObTableRedefinitionTask::send_build_replica_request_by_sql()
}
ObSchemaGetterGuard schema_guard;
const ObTableSchema *orig_table_schema = nullptr;
const ObTableSchema *hidden_table_schema = nullptr;
ObDDLRedefinitionSSTableBuildTask task(
task_id_,
tenant_id_,
@ -301,18 +274,13 @@ int ObTableRedefinitionTask::send_build_replica_request_by_sql()
trace_id_,
parallelism_,
use_heap_table_ddl_plan,
alter_table_arg_.mview_refresh_info_.is_mview_complete_refresh_,
alter_table_arg_.mview_refresh_info_.mview_table_id_,
GCTX.root_service_,
alter_table_arg_.inner_sql_exec_addr_,
data_format_version_);
alter_table_arg_.inner_sql_exec_addr_);
if (OB_FAIL(root_service->get_ddl_service().get_tenant_schema_guard_with_version_in_inner_table(tenant_id_, schema_guard))) {
LOG_WARN("get schema guard failed", K(ret));
} else if (OB_FAIL(schema_guard.get_table_schema(tenant_id_, object_id_, orig_table_schema))) {
LOG_WARN("failed to get orig table schema", K(ret));
} else if (OB_FAIL(schema_guard.get_table_schema(dst_tenant_id_, target_object_id_, hidden_table_schema))) {
LOG_WARN("fail to get table schema", K(ret), K(target_object_id_));
} else if (OB_FAIL(task.init(*orig_table_schema, *hidden_table_schema, alter_table_arg_.alter_table_schema_, alter_table_arg_.tz_info_wrap_, alter_table_arg_.based_schema_object_infos_))) {
} else if (OB_FAIL(task.init(*orig_table_schema, alter_table_arg_.alter_table_schema_, alter_table_arg_.tz_info_wrap_))) {
LOG_WARN("fail to init table redefinition sstable build task", K(ret));
} else if (OB_FAIL(root_service->submit_ddl_single_replica_build_task(task))) {
LOG_WARN("fail to submit ddl build single replica", K(ret));
@ -355,8 +323,6 @@ int ObTableRedefinitionTask::check_use_heap_table_ddl_plan(bool &use_heap_table_
if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, TABLE_REDEF_TASK_CHECK_USE_HEAP_PLAN_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else if (OB_FAIL(root_service->get_ddl_service()
.get_tenant_schema_guard_with_version_in_inner_table(dst_tenant_id_, schema_guard))) {
LOG_WARN("get schema guard failed", K(ret));
@ -366,8 +332,7 @@ int ObTableRedefinitionTask::check_use_heap_table_ddl_plan(bool &use_heap_table_
ret = OB_ERR_UNEXPECTED;
LOG_WARN("error unexpected, table schema must not be nullptr", K(ret), K(target_object_id_));
} else if (target_table_schema->is_heap_table() &&
(DDL_ALTER_PARTITION_BY == task_type_ || DDL_DROP_PRIMARY_KEY == task_type_ ||
DDL_MVIEW_COMPLETE_REFRESH == task_type_)) {
(DDL_ALTER_PARTITION_BY == task_type_ || DDL_DROP_PRIMARY_KEY == task_type_)) {
use_heap_table_ddl_plan = true;
}
return ret;
@ -413,12 +378,7 @@ int ObTableRedefinitionTask::table_redefinition(const ObDDLTaskStatus next_task_
// overwrite ret
if (is_build_replica_end) {
ret = OB_SUCC(ret) ? complete_sstable_job_ret_code_ : ret;
bool need_verify_checksum = true;
#ifdef ERRSIM
// when the major compaction is delayed, skip verify column checksum
need_verify_checksum = 0 == GCONF.errsim_ddl_major_delay_time;
#endif
if (OB_SUCC(ret) && need_verify_checksum) {
if (OB_SUCC(ret)) {
if (OB_FAIL(replica_end_check(ret))) {
LOG_WARN("fail to check", K(ret));
}
@ -435,8 +395,7 @@ int ObTableRedefinitionTask::replica_end_check(const int ret_code)
int ret = OB_SUCCESS;
switch(task_type_) {
case DDL_DIRECT_LOAD :
case DDL_DIRECT_LOAD_INSERT :
case DDL_MVIEW_COMPLETE_REFRESH: {
case DDL_DIRECT_LOAD_INSERT : {
break;
}
default : {
@ -459,8 +418,6 @@ int ObTableRedefinitionTask::copy_table_indexes()
} else if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, REDEF_TASK_COPY_INDEX_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else {
const int64_t MAX_ACTIVE_TASK_CNT = 1;
int64_t active_task_cnt = 0;
@ -523,9 +480,6 @@ int ObTableRedefinitionTask::copy_table_indexes()
ObDDLTaskRecord task_record;
bool need_rebuild_index = true;
SMART_VAR(ObCreateIndexArg, create_index_arg) {
ObTraceIdGuard trace_id_guard(get_trace_id());
ATOMIC_INC(&sub_task_trace_id_);
ObDDLEventInfo ddl_event_info(sub_task_trace_id_);
// this create index arg is not valid, only has nls format
create_index_arg.nls_date_format_ = alter_table_arg_.nls_formats_[0];
create_index_arg.nls_timestamp_format_ = alter_table_arg_.nls_formats_[1];
@ -554,8 +508,6 @@ int ObTableRedefinitionTask::copy_table_indexes()
&allocator_,
&create_index_arg,
task_id_);
param.sub_task_trace_id_ = sub_task_trace_id_;
param.tenant_data_version_ = data_format_version_;
if (OB_FAIL(GCTX.root_service_->get_ddl_task_scheduler().create_ddl_task(param, *GCTX.sql_proxy_, task_record))) {
if (OB_ENTRY_EXIST == ret) {
ret = OB_SUCCESS;
@ -568,10 +520,7 @@ int ObTableRedefinitionTask::copy_table_indexes()
LOG_WARN("fail to schedule ddl task", K(ret), K(task_record));
}
}
if (OB_FAIL(ret)) {
add_event_info("create table_redefinition index task fail");
LOG_WARN("add build index task failed", K(ret), K(task_record), K(ddl_event_info));
} else if (need_rebuild_index) {
if (OB_SUCC(ret) && need_rebuild_index) {
TCWLockGuard guard(lock_);
const uint64_t task_key = index_ids.at(i);
DependTaskStatus status;
@ -583,8 +532,7 @@ int ObTableRedefinitionTask::copy_table_indexes()
LOG_WARN("set dependent task map failed", K(ret), K(task_key));
}
}
add_event_info("create table_redefinition index task succ");
LOG_INFO("add build index task", K(ret), K(task_key), K(status), K(ddl_event_info));
LOG_INFO("add build index task", K(ret), K(task_key), K(status));
}
}
}
@ -609,8 +557,6 @@ int ObTableRedefinitionTask::copy_table_constraints()
} else if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, REDEF_TASK_COPY_CONSTRAINT_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else {
if (has_rebuild_constraint_) {
// do nothing
@ -678,8 +624,6 @@ int ObTableRedefinitionTask::copy_table_foreign_keys()
} else if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, REDEF_TASK_COPY_FOREIGN_KEY_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else {
if (has_rebuild_foreign_key_) {
// do nothing
@ -743,8 +687,6 @@ int ObTableRedefinitionTask::copy_table_dependent_objects(const ObDDLTaskStatus
} else if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, REDEF_TASK_COPY_DEPENDENT_OBJECTS_FAILED))) {
LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
} else if (!dependent_task_result_map_.created() && OB_FAIL(dependent_task_result_map_.create(MAX_DEPEND_OBJECT_COUNT, lib::ObLabel("DepTasMap")))) {
LOG_WARN("create dependent task map failed", K(ret));
} else {
@ -820,7 +762,7 @@ int ObTableRedefinitionTask::take_effect(const ObDDLTaskStatus next_task_status)
{
int ret = OB_SUCCESS;
#ifdef ERRSIM
ROOTSERVICE_EVENT_ADD("ddl_task", "before_table_redefinition_task_effect",
SERVER_EVENT_ADD("ddl_task", "before_table_redefinition_task_effect",
"tenant_id", tenant_id_,
"object_id", object_id_,
"target_object_id", target_object_id_);
@ -846,8 +788,6 @@ int ObTableRedefinitionTask::take_effect(const ObDDLTaskStatus next_task_status)
} else if (OB_ISNULL(root_service)) {
ret = OB_ERR_SYS;
LOG_WARN("error sys, root service must not be nullptr", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, DDL_TASK_TAKE_EFFECT_FAILED))) {
LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
} else if (OB_FAIL(ObMultiVersionSchemaService::get_instance().get_tenant_schema_guard(dst_tenant_id_, schema_guard))) {
LOG_WARN("get tenant schema guard failed", K(ret));
} else if (OB_FAIL(schema_guard.get_table_schema(dst_tenant_id_, target_object_id_, table_schema))) {
@ -873,13 +813,8 @@ int ObTableRedefinitionTask::take_effect(const ObDDLTaskStatus next_task_status)
} else {
LOG_WARN("sync auto increment position failed", K(ret), K(object_id_), K(target_object_id_));
}
} else if (ObDDLType::DDL_DIRECT_LOAD != task_type_ &&
ObDDLType::DDL_DIRECT_LOAD_INSERT != task_type_ &&
OB_FAIL(sync_stats_info())) {//direct load no need sync stats info, because the stats have been regather
} else if (OB_FAIL(sync_stats_info())) {
LOG_WARN("fail to sync stats info", K(ret), K(object_id_), K(target_object_id_));
} else if (alter_table_arg_.mview_refresh_info_.is_mview_complete_refresh_ &&
OB_FAIL(alter_table_arg_.mview_refresh_info_.refresh_scn_.convert_for_inner_table_field(snapshot_version_))) {
LOG_WARN("fail to convert scn", K(ret), K(snapshot_version_));
} else if (OB_FAIL(ObDDLUtil::get_ddl_rpc_timeout(dst_tenant_id_, target_object_id_, ddl_rpc_timeout))) {
LOG_WARN("get ddl rpc timeout fail", K(ret));
} else if (OB_FAIL(root_service->get_ddl_service().get_common_rpc()->to(obrpc::ObRpcProxy::myaddr_).timeout(ddl_rpc_timeout).
@ -896,18 +831,6 @@ int ObTableRedefinitionTask::take_effect(const ObDDLTaskStatus next_task_status)
LOG_WARN("fail to switch status", K(ret));
}
}
char object_id_buffer[256];
snprintf(object_id_buffer, sizeof(object_id_buffer), "object_id:%ld, target_object_id:%ld",
object_id_, target_object_id_);
ROOTSERVICE_EVENT_ADD("ddl scheduler", "table redefinition task take effect",
"tenant_id", tenant_id_,
"ret", ret,
K_(trace_id),
K_(task_id),
"object_id", object_id_buffer,
K_(schema_version),
next_task_status);
LOG_INFO("table redefinition task take effect", K(ret), "ddl_event_info", ObDDLEventInfo(), K(*this));
return ret;
}
@ -917,8 +840,6 @@ int ObTableRedefinitionTask::repending(const share::ObDDLTaskStatus next_task_st
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("ObDDLRedefinitionTask has not been inited", K(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, TABLE_REDEF_TASK_REPENDING_FAILED))) {
LOG_WARN("ddl sim failure", K(tenant_id_), K(task_id_));
} else {
switch (task_type_) {
case DDL_DIRECT_LOAD:
@ -956,20 +877,8 @@ int ObTableRedefinitionTask::process()
ddl_tracing_.restore_span_hierarchy();
switch(task_status_) {
case ObDDLTaskStatus::PREPARE:
if (alter_table_arg_.mview_refresh_info_.is_mview_complete_refresh_ && parent_task_id_ > 0) {
const ObDDLTaskID parent_task_id(tenant_id_, parent_task_id_);
ObRootService *root_service = GCTX.root_service_;
if (OB_ISNULL(root_service)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("error unexpected, root service must not be nullptr", K(ret));
} else if (OB_FAIL(root_service->get_ddl_task_scheduler().on_ddl_task_prepare(parent_task_id, task_id_, trace_id_))) {
LOG_WARN("fail to do parent task callback", KR(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(prepare(ObDDLTaskStatus::WAIT_TRANS_END))) {
LOG_WARN("fail to prepare table redefinition task", K(ret));
}
if (OB_FAIL(prepare(ObDDLTaskStatus::WAIT_TRANS_END))) {
LOG_WARN("fail to prepare table redefinition task", K(ret));
}
break;
case ObDDLTaskStatus::WAIT_TRANS_END:
@ -1062,9 +971,7 @@ int64_t ObTableRedefinitionTask::get_serialize_param_size() const
return alter_table_arg_.get_serialize_size() + ObDDLTask::get_serialize_param_size()
+ serialization::encoded_length_i8(copy_indexes) + serialization::encoded_length_i8(copy_triggers)
+ serialization::encoded_length_i8(copy_constraints) + serialization::encoded_length_i8(copy_foreign_keys)
+ serialization::encoded_length_i8(ignore_errors) + serialization::encoded_length_i8(do_finish)
+ serialization::encoded_length_i64(target_cg_cnt_)
+ serialization::encoded_length_i64(complete_sstable_job_ret_code_);
+ serialization::encoded_length_i8(ignore_errors) + serialization::encoded_length_i8(do_finish);
}
int ObTableRedefinitionTask::serialize_params_to_message(char *buf, const int64_t buf_len, int64_t &pos) const
@ -1095,10 +1002,6 @@ int ObTableRedefinitionTask::serialize_params_to_message(char *buf, const int64_
LOG_WARN("fail to serialize is_ignore_errors", K(ret));
} else if (OB_FAIL(serialization::encode_i8(buf, buf_len, pos, do_finish))) {
LOG_WARN("fail to serialize is_do_finish", K(ret));
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, pos, target_cg_cnt_))) {
LOG_WARN("fail to serialize target_cg_cnt", K(ret));
} else if (OB_FAIL(serialization::encode_i64(buf, buf_len, pos, complete_sstable_job_ret_code_))) {
LOG_WARN("fail to serialize complete sstable job ret code", K(ret));
}
FLOG_INFO("serialize message for table redefinition", K(ret),
K(copy_indexes), K(copy_triggers), K(copy_constraints), K(copy_foreign_keys), K(ignore_errors), K(do_finish), K(*this));
@ -1139,10 +1042,7 @@ int ObTableRedefinitionTask::deserlize_params_from_message(const uint64_t tenant
LOG_WARN("fail to deserialize is_ignore_errors_", K(ret));
} else if (OB_FAIL(serialization::decode_i8(buf, data_len, pos, &do_finish))) {
LOG_WARN("fail to deserialize is_do_finish_", K(ret));
} else if (OB_FAIL(serialization::decode_i64(buf, data_len, pos, &target_cg_cnt_))) {
LOG_WARN("fail to deserialize target_cg_ctn_", K(ret));
}
else {
} else {
is_copy_indexes_ = static_cast<bool>(copy_indexes);
is_copy_triggers_ = static_cast<bool>(copy_triggers);
is_copy_constraints_ = static_cast<bool>(copy_constraints);
@ -1150,11 +1050,6 @@ int ObTableRedefinitionTask::deserlize_params_from_message(const uint64_t tenant
is_ignore_errors_ = static_cast<bool>(ignore_errors);
is_do_finish_ = static_cast<bool>(do_finish);
}
if (OB_SUCC(ret) && pos < data_len) {
if (OB_FAIL(serialization::decode_i64(buf, data_len, pos, &complete_sstable_job_ret_code_))) {
LOG_WARN("fail to deserialize is_do_finish_", K(ret));
}
}
}
FLOG_INFO("deserialize message for table redefinition", K(ret),
K(copy_indexes), K(copy_triggers), K(copy_constraints), K(copy_foreign_keys), K(ignore_errors), K(do_finish), K(*this));
@ -1236,37 +1131,17 @@ int ObTableRedefinitionTask::collect_longops_stat(ObLongopsValue &value)
case ObDDLTaskStatus::REDEFINITION: {
int64_t row_scanned = 0;
int64_t row_sorted = 0;
int64_t row_inserted_cg = 0;
int64_t row_inserted_file = 0;
if (OB_FAIL(gather_redefinition_stats(dst_tenant_id_, task_id_, *GCTX.sql_proxy_, row_scanned, row_sorted, row_inserted_cg, row_inserted_file))) {
int64_t row_inserted = 0;
if (OB_FAIL(gather_redefinition_stats(dst_tenant_id_, task_id_, *GCTX.sql_proxy_, row_scanned, row_sorted, row_inserted))) {
LOG_WARN("failed to gather redefinition stats", K(ret));
}
if (OB_FAIL(ret)){
} else if (target_cg_cnt_> 1) {
if (OB_FAIL(databuff_printf(stat_info_.message_,
MAX_LONG_OPS_MESSAGE_LENGTH,
pos,
"STATUS: REPLICA BUILD, ROW_SCANNED: %ld, ROW_SORTED: %ld, ROW_INSERTED_TMP_FILE: %ld, ROW_INSERTED: %ld out of %ld column group rows",
row_scanned,
row_sorted,
row_inserted_file,
row_inserted_cg,
row_scanned * target_cg_cnt_))) {
LOG_WARN("failed to print", K(ret));
}
} else {
if (OB_FAIL(databuff_printf(stat_info_.message_,
MAX_LONG_OPS_MESSAGE_LENGTH,
pos,
"STATUS: REPLICA BUILD, ROW_SCANNED: %ld, ROW_SORTED: %ld, ROW_INSERTED: %ld",
row_scanned,
row_sorted,
row_inserted_file))) {
LOG_WARN("failed to print", K(ret));
}
} else if (OB_FAIL(databuff_printf(stat_info_.message_,
MAX_LONG_OPS_MESSAGE_LENGTH,
pos,
"STATUS: REPLICA BUILD, ROW_SCANNED: %ld, ROW_SORTED: %ld, ROW_INSERTED: %ld",
row_scanned,
row_sorted,
row_inserted))) {
LOG_WARN("failed to print", K(ret));
}
break;
}
@ -1366,8 +1241,6 @@ int ObTableRedefinitionTask::collect_longops_stat(ObLongopsValue &value)
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, DDL_TASK_COLLECT_LONGOPS_STAT_FAILED))) {
LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
} else if (OB_FAIL(copy_longops_stat(value))) {
LOG_WARN("failed to collect common longops stat", K(ret));
}
@ -1444,10 +1317,6 @@ int ObTableRedefinitionTask::get_direct_load_job_stat(common::ObArenaAllocator &
"AND JOB_ID=%ld AND JOB_TYPE='direct' AND COORDINATOR_STATUS!='none'",
OB_ALL_VIRTUAL_LOAD_DATA_STAT_TNAME, tenant_id_, object_id_))) {
LOG_WARN("failed to assign sql", KR(ret));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, TABLE_REDEF_TASK_GET_DIRECT_LOAD_JOB_STAT_FAILED))) {
LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
} else if (OB_FAIL(DDL_SIM(tenant_id_, task_id_, TABLE_REDEF_TASK_GET_DIRECT_LOAD_JOB_STAT_SLOW))) {
LOG_WARN("ddl sim failure", K(ret), K(tenant_id_), K(task_id_));
} else if (OB_FAIL(sql_proxy.read(select_res, OB_SYS_TENANT_ID, select_sql.ptr()))) {
LOG_WARN("fail to execute sql", KR(ret), K(select_sql));
} else if (OB_ISNULL(select_result = select_res.get_result())) {