diff --git a/src/observer/ob_service.cpp b/src/observer/ob_service.cpp index 671b882d1f..950ac211da 100644 --- a/src/observer/ob_service.cpp +++ b/src/observer/ob_service.cpp @@ -731,6 +731,7 @@ int ObService::backup_completing_log(const obrpc::ObBackupComplLogArg &arg) SCN start_scn = arg.start_scn_; SCN end_scn = arg.end_scn_; ObLSID ls_id = arg.ls_id_; + const bool is_only_calc_stat = arg.is_only_calc_stat_; ObMySQLProxy *sql_proxy = GCTX.sql_proxy_; if (!arg.is_valid() || OB_ISNULL(sql_proxy)) { ret = OB_INVALID_ARGUMENT; @@ -738,7 +739,7 @@ int ObService::backup_completing_log(const obrpc::ObBackupComplLogArg &arg) } else if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy, tenant_id, arg.backup_path_, backup_dest))) { LOG_WARN("failed to get backup dest", KR(ret), K(arg)); } else if (OB_FAIL(ObBackupHandler::schedule_backup_complement_log_dag( - job_desc, backup_dest, tenant_id, backup_set_desc, ls_id, start_scn, end_scn))) { + job_desc, backup_dest, tenant_id, backup_set_desc, ls_id, start_scn, end_scn, is_only_calc_stat))) { LOG_WARN("failed to schedule backup data dag", KR(ret), K(arg)); } else { SERVER_EVENT_ADD("backup_data", "schedule_backup_complement_log", diff --git a/src/rootserver/backup/ob_backup_data_ls_task_mgr.cpp b/src/rootserver/backup/ob_backup_data_ls_task_mgr.cpp index e78289bea7..92ca7ab36e 100755 --- a/src/rootserver/backup/ob_backup_data_ls_task_mgr.cpp +++ b/src/rootserver/backup/ob_backup_data_ls_task_mgr.cpp @@ -134,6 +134,7 @@ int ObBackupDataLSTaskMgr::gen_and_add_task_() } break; } + case ObBackupDataTaskType::Type::BEFORE_PLUS_ARCHIVE_LOG: case ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG: { if (OB_FAIL(gen_and_add_backup_compl_log_())) { LOG_WARN("[DATA_BACKUP]failed to gen and add backup complement task", K(ret), KPC(ls_attr_)); diff --git a/src/rootserver/backup/ob_backup_data_scheduler.cpp b/src/rootserver/backup/ob_backup_data_scheduler.cpp index 33e235bbdd..31ada578f8 100644 --- a/src/rootserver/backup/ob_backup_data_scheduler.cpp +++ b/src/rootserver/backup/ob_backup_data_scheduler.cpp @@ -202,6 +202,7 @@ int ObBackupDataScheduler::build_task_( } break; } + case ObBackupDataTaskType::Type::BEFORE_PLUS_ARCHIVE_LOG: case ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG: { HEAP_VAR(ObBackupComplLogTask, tmp_task) { if (OB_FAIL(do_build_task_(job, set_task_attr, ls_task, allocator, tmp_task, task))) { diff --git a/src/rootserver/backup/ob_backup_data_set_task_mgr.cpp b/src/rootserver/backup/ob_backup_data_set_task_mgr.cpp index 9a634923dc..38f6fb4712 100644 --- a/src/rootserver/backup/ob_backup_data_set_task_mgr.cpp +++ b/src/rootserver/backup/ob_backup_data_set_task_mgr.cpp @@ -171,6 +171,12 @@ int ObBackupSetTaskMgr::process() } break; } + case ObBackupStatus::Status::BEFORE_BACKUP_LOG: { + if (OB_FAIL(before_backup_log_())) { + LOG_WARN("[DATA_BACKUP]failed to before backup log", K(ret), K(set_task_attr_)); + } + break; + } case ObBackupStatus::Status::BACKUP_LOG: { if (OB_FAIL(backup_completing_log_())) { LOG_WARN("[DATA_BACKUP]failed to backup completing log", K(ret), K(set_task_attr_)); @@ -1031,6 +1037,10 @@ int ObBackupSetTaskMgr::get_next_status_(const share::ObBackupStatus &cur_status break; } case ObBackupStatus::Status::BACKUP_DATA_MAJOR: { + next_status = ObBackupStatus::Status::BEFORE_BACKUP_LOG; + break; + } + case ObBackupStatus::Status::BEFORE_BACKUP_LOG: { next_status = ObBackupStatus::Status::BACKUP_LOG; break; } @@ -1582,6 +1592,10 @@ int ObBackupSetTaskMgr::convert_task_type_(const ObIArray &l break; } case ObBackupStatus::Status::BACKUP_DATA_MAJOR: { + type.type_ = ObBackupDataTaskType::Type::BEFORE_PLUS_ARCHIVE_LOG; + break; + } + case ObBackupStatus::Status::BEFORE_BACKUP_LOG: { type.type_ = ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG; break; } @@ -1696,7 +1710,7 @@ int ObBackupSetTaskMgr::do_failed_ls_task_(ObMySQLTransaction &trans, const ObIA return ret; } -int ObBackupSetTaskMgr::backup_completing_log_() +int ObBackupSetTaskMgr::before_backup_log_() { int ret = OB_SUCCESS; ObArray ls_task; @@ -1725,6 +1739,90 @@ int ObBackupSetTaskMgr::backup_completing_log_() finish_cnt = ls_task.count(); } + if (OB_SUCC(ret) && ls_task.count() == finish_cnt) { + if (OB_FAIL(trans_.start(sql_proxy_, meta_tenant_id_))) { + LOG_WARN("fail to start trans", K(ret), K(meta_tenant_id_)); + } else { + ObBackupStatus next_status = ObBackupStatus::BACKUP_LOG; + share::ObBackupDataTaskType type(share::ObBackupDataTaskType::Type::BACKUP_PLUS_ARCHIVE_LOG); + if (OB_FAIL(stat_all_ls_backup_log_(trans_))) { + LOG_WARN("[DATA_BACKUP]fail to stat all ls backup log", K(ret)); + } else if (OB_FAIL(convert_task_type_(ls_task))) { + LOG_WARN("[DATA_BACKUP]fail to update task type to backup data", K(ret)); + } else if (OB_FAIL(advance_status_(trans_, next_status, OB_SUCCESS, set_task_attr_.end_scn_, set_task_attr_.end_ts_))) { + LOG_WARN("[DATA_BACKUP]failed to advance status to BACKUP_PLUS_ARCHIVE_LOG", K(ret), K(next_status)); + } + + if (OB_SUCC(ret)) { + if (OB_FAIL(trans_.end(true))) { + LOG_WARN("fail to commit trans", K(ret)); + } else { + set_task_attr_.status_ = next_status; + ROOTSERVICE_EVENT_ADD("backup_data", "before backup completing log succeed", "tenant_id", + job_attr_->tenant_id_, "job_id", job_attr_->job_id_, "task_id", set_task_attr_.task_id_); + backup_service_->wakeup(); + } + } else { + int tmp_ret = OB_SUCCESS; + if (OB_SUCCESS != (tmp_ret = trans_.end(false))) { + LOG_WARN("fail to rollback", K(ret), K(tmp_ret)); + } + } + } + } + return ret; +} + +int ObBackupSetTaskMgr::stat_all_ls_backup_log_(ObMySQLTransaction &trans) +{ + int ret = OB_SUCCESS; + const bool for_update = true; + ObArray ls_attrs; + share::ObBackupSetTaskAttr old_set_task_attr; + share::ObBackupStats new_backup_set_stats; + if (OB_FAIL(ObBackupTaskOperator::get_backup_task(trans, + job_attr_->job_id_, job_attr_->tenant_id_, for_update, old_set_task_attr))) { + LOG_WARN("failed to get backup task", K(ret)); + } else if (OB_FAIL(ObBackupLSTaskOperator::get_ls_tasks(trans, + job_attr_->job_id_, job_attr_->tenant_id_, for_update, ls_attrs))) { + LOG_WARN("failed to get ls tasks", K(ret), KPC_(job_attr)); + } else { + int64_t total_compl_log_file_count = 0; + ARRAY_FOREACH_X(ls_attrs, idx, cnt, OB_SUCC(ret)) { + const ObBackupLSTaskAttr &ls_attr = ls_attrs.at(idx); + total_compl_log_file_count += ls_attr.stats_.log_file_count_; + } + new_backup_set_stats = old_set_task_attr.stats_; + new_backup_set_stats.log_file_count_ = total_compl_log_file_count; + if (FAILEDx(ObBackupTaskOperator::update_stats(trans, set_task_attr_.task_id_, + job_attr_->tenant_id_, new_backup_set_stats))) { + LOG_WARN("failed to update stats", K(ret)); + } else { + LOG_INFO("update stats", K(new_backup_set_stats)); + } + } + return ret; +} + +int ObBackupSetTaskMgr::backup_completing_log_() +{ + int ret = OB_SUCCESS; + ObArray ls_task; + ObTenantArchiveRoundAttr round_attr; + int64_t finish_cnt = 0; + if (OB_FAIL(ObBackupLSTaskOperator::get_ls_tasks(*sql_proxy_, job_attr_->job_id_, job_attr_->tenant_id_, true/*update*/, ls_task))) { + LOG_WARN("[DATA_BACKUP]failed to get log stream tasks", K(ret), "job_id", job_attr_->job_id_, "tenant_id", job_attr_->tenant_id_); + } else if (ls_task.empty()) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("[DATA_BACKUP]no logstream task", K(ret), K(ls_task)); + } else if (job_attr_->plus_archivelog_) { + if (OB_FAIL(do_backup_completing_log_(ls_task, finish_cnt))) { + LOG_WARN("[DATA_BACKUP]failed to do backup ls task", K(ret), K(set_task_attr_), K(ls_task)); + } + } else { + finish_cnt = ls_task.count(); + } + if (OB_SUCC(ret) && ls_task.count() == finish_cnt) { ObBackupStatus next_status = ObBackupStatus::COMPLETED; set_task_attr_.end_ts_ = ObTimeUtility::current_time(); diff --git a/src/rootserver/backup/ob_backup_data_set_task_mgr.h b/src/rootserver/backup/ob_backup_data_set_task_mgr.h index 6f3bb83526..a4ea5f1a13 100644 --- a/src/rootserver/backup/ob_backup_data_set_task_mgr.h +++ b/src/rootserver/backup/ob_backup_data_set_task_mgr.h @@ -105,6 +105,8 @@ private: int update_inner_task_(const ObIArray &new_ls_ids, const ObIArray &need_change_turn_ls_tasks); int convert_task_type_(const ObIArray &ls_task); + int before_backup_log_(); + int stat_all_ls_backup_log_(ObMySQLTransaction &trans); int backup_completing_log_(); int do_backup_completing_log_(ObArray &ls_task, int64_t &finish_cnt); int calculate_start_replay_scn_(share::SCN &start_replay_scn); diff --git a/src/rootserver/backup/ob_backup_schedule_task.cpp b/src/rootserver/backup/ob_backup_schedule_task.cpp index 37a49315ab..1958a58135 100644 --- a/src/rootserver/backup/ob_backup_schedule_task.cpp +++ b/src/rootserver/backup/ob_backup_schedule_task.cpp @@ -317,7 +317,8 @@ ObBackupDataBaseTask::ObBackupDataBaseTask() backup_user_ls_scn_(), end_scn_(), backup_path_(), - backup_status_() + backup_status_(), + is_only_calc_stat_(false) { } @@ -340,6 +341,7 @@ int ObBackupDataBaseTask::deep_copy(const ObBackupDataBaseTask &that) backup_user_ls_scn_ = that.backup_user_ls_scn_; end_scn_ = that.end_scn_; backup_status_.status_ = that.backup_status_.status_; + is_only_calc_stat_ = that.is_only_calc_stat_; } return ret; } @@ -377,7 +379,7 @@ int ObBackupDataBaseTask::build(const share::ObBackupJobAttr &job_attr, const sh int ret = OB_SUCCESS; ObBackupScheduleTaskKey key; if (!job_attr.is_valid() || !ls_attr.is_valid()) { - ret = OB_SUCCESS; + ret = OB_INVALID_ARGUMENT; LOG_WARN("invalid argument", K(ret), K(job_attr), K(ls_attr)); } else if (OB_FAIL(key.init(ls_attr.tenant_id_, job_attr.job_id_, ls_attr.task_id_, ls_attr.ls_id_.id(), BackupJobType::BACKUP_DATA_JOB))) { LOG_WARN("failed to init backup schedule task key", K(ret), K(job_attr), K(ls_attr)); @@ -573,7 +575,7 @@ int ObBackupComplLogTask::build(const share::ObBackupJobAttr &job_attr, const sh ObBackupScheduleTaskKey key; share::SCN start_replay_scn; if (!job_attr.is_valid() || !ls_attr.is_valid()) { - ret = OB_SUCCESS; + ret = OB_INVALID_ARGUMENT; LOG_WARN("invalid argument", K(ret), K(job_attr), K(ls_attr)); } else if (OB_FAIL(key.init(ls_attr.tenant_id_, job_attr.job_id_, ls_attr.task_id_, ls_attr.ls_id_.id(), BackupJobType::BACKUP_DATA_JOB))) { LOG_WARN("failed to init backup schedule task key", K(ret), K(job_attr), K(ls_attr)); @@ -592,6 +594,7 @@ int ObBackupComplLogTask::build(const share::ObBackupJobAttr &job_attr, const sh backup_status_.status_ = set_task_attr.status_.status_; turn_id_ = ls_attr.turn_id_; retry_id_ = ls_attr.retry_id_; + is_only_calc_stat_ = ObBackupStatus::BEFORE_BACKUP_LOG == set_task_attr.status_.status_; if (OB_FAIL(backup_path_.assign(job_attr.backup_path_))) { LOG_WARN("failed to assign backup dest", K(ret), "backup dest", job_attr.backup_path_); } else if (OB_FAIL(set_optional_servers_(ls_attr.black_servers_))) { @@ -617,6 +620,7 @@ int ObBackupComplLogTask::execute(obrpc::ObSrvRpcProxy &rpc_proxy) const arg.start_scn_ = start_scn_; arg.end_scn_ = end_scn_; arg.backup_type_ = backup_type_.type_; + arg.is_only_calc_stat_ = is_only_calc_stat_; if (OB_FAIL(arg.backup_path_.assign(backup_path_))) { LOG_WARN("failed to assign backup dest", K(ret), K(backup_path_)); } else if (OB_FAIL(rpc_proxy.to(get_dst()).backup_completing_log(arg))) { diff --git a/src/rootserver/backup/ob_backup_schedule_task.h b/src/rootserver/backup/ob_backup_schedule_task.h index 684eabe105..c26340a128 100644 --- a/src/rootserver/backup/ob_backup_schedule_task.h +++ b/src/rootserver/backup/ob_backup_schedule_task.h @@ -291,6 +291,7 @@ protected: share::SCN end_scn_; share::ObBackupPathString backup_path_; share::ObBackupStatus backup_status_; + bool is_only_calc_stat_; private: DISALLOW_COPY_AND_ASSIGN(ObBackupDataBaseTask); }; diff --git a/src/share/backup/ob_backup_data_table_operator.cpp b/src/share/backup/ob_backup_data_table_operator.cpp index 4be161e4a1..1dfd11d411 100644 --- a/src/share/backup/ob_backup_data_table_operator.cpp +++ b/src/share/backup/ob_backup_data_table_operator.cpp @@ -1384,6 +1384,8 @@ int ObBackupTaskOperator::get_backup_task( EXTRACT_STRBUF_FIELD_MYSQL(*result, OB_STR_PATH, backup_path_str, OB_MAX_BACKUP_DEST_LENGTH, tmp_str_len); EXTRACT_INT_FIELD_MYSQL(*result, OB_STR_MINOR_TURN_ID, set_task_attr.minor_turn_id_, int64_t); EXTRACT_INT_FIELD_MYSQL(*result, OB_STR_MAJOR_TURN_ID, set_task_attr.major_turn_id_, int64_t); + EXTRACT_INT_FIELD_MYSQL(*result, OB_STR_LOG_FILE_COUNT, set_task_attr.stats_.log_file_count_, int64_t); + EXTRACT_INT_FIELD_MYSQL(*result, OB_STR_FINISH_LOG_FILE_COUNT, set_task_attr.stats_.finish_log_file_count_, int64_t); if (OB_FAIL(ret)) { } else if (OB_FAIL(set_task_attr.status_.set_status(status_str))) { @@ -1497,9 +1499,15 @@ int ObBackupTaskOperator::update_stats( ObSqlString sql; int64_t affected_rows = -1; ObDMLSqlSplicer dml; + uint64_t data_version = 0; if (task_id <= 0 || tenant_id == OB_INVALID_TENANT_ID || !stats.is_valid()) { ret = OB_INVALID_ARGUMENT; LOG_WARN("[DATA_BACKUP]invalid argument", K(ret), K(task_id), K(tenant_id), K(stats)); + } else if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, data_version))) { + LOG_WARN("failed to get min data version"); + } else if (data_version < DATA_VERSION_4_3_1_0) { + ret = OB_NOT_SUPPORTED; + LOG_WARN("VALUES STATEMENT is not supported", K(ret), K(data_version)); } else if (OB_FAIL(dml.add_pk_column(OB_STR_TASK_ID, task_id))) { LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.add_pk_column(OB_STR_TENANT_ID, tenant_id))) { @@ -1520,6 +1528,10 @@ int ObBackupTaskOperator::update_stats( LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.add_column(OB_STR_FILE_COUNT, stats.finish_file_count_))) { LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } else if (OB_FAIL(dml.add_column(OB_STR_LOG_FILE_COUNT, stats.log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } else if (OB_FAIL(dml.add_column(OB_STR_FINISH_LOG_FILE_COUNT, stats.finish_log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.splice_update_sql(OB_ALL_BACKUP_TASK_TNAME, sql))) { LOG_WARN("[DATA_BACKUP]failed to splice_update_sql", K(ret)); } else if (OB_FAIL(proxy.write(get_exec_tenant_id(tenant_id), sql.ptr(), affected_rows))) { @@ -1754,7 +1766,11 @@ int ObBackupLSTaskOperator::fill_dml_with_ls_task_( LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.add_uint64_column(OB_STR_MAX_TABLET_CHECKPOINT_SCN, ls_attr.max_tablet_checkpoint_scn_.get_val_for_inner_table_field()))) { LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); - } + } else if (OB_FAIL(dml.add_column(OB_STR_LOG_FILE_COUNT, ls_attr.stats_.log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } else if (OB_FAIL(dml.add_column(OB_STR_FINISH_LOG_FILE_COUNT, ls_attr.stats_.finish_log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } return ret; } @@ -1900,6 +1916,10 @@ int ObBackupLSTaskOperator::fill_select_ls_task_sql_(ObSqlString &sql) LOG_WARN("[DATA_BACKUP]failed to append fmt", K(ret)); } else if (OB_FAIL(sql.append_fmt(", %s", OB_STR_MAX_TABLET_CHECKPOINT_SCN))) { LOG_WARN("[DATA_BACKUP]failed to append fmt", K(ret)); + } else if (OB_FAIL(sql.append_fmt(", %s", OB_STR_LOG_FILE_COUNT))) { + LOG_WARN("[DATA_BACKUP]failed to append fmt", K(ret)); + } else if (OB_FAIL(sql.append_fmt(", %s", OB_STR_FINISH_LOG_FILE_COUNT))) { + LOG_WARN("[DATA_BACKUP]failed to append fmt", K(ret)); } else if (OB_FAIL(sql.append_fmt(" from %s", OB_ALL_BACKUP_LS_TASK_TNAME))) { LOG_WARN("[DATA_BACKUP]failed to append fmt", K(ret)); } @@ -1970,6 +1990,8 @@ int ObBackupLSTaskOperator::do_parse_ls_result_(ObMySQLResult &result, ObBackupL EXTRACT_INT_FIELD_MYSQL(result, OB_STR_FILE_COUNT, ls_attr.stats_.finish_file_count_, int64_t); EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_COMMENT, comment_str, MAX_TABLE_COMMENT_LENGTH, real_length); EXTRACT_UINT_FIELD_MYSQL(result, OB_STR_MAX_TABLET_CHECKPOINT_SCN, max_tablet_checkpoint_scn, uint64_t); + EXTRACT_INT_FIELD_MYSQL(result, OB_STR_LOG_FILE_COUNT, ls_attr.stats_.log_file_count_, int64_t); + EXTRACT_INT_FIELD_MYSQL(result, OB_STR_FINISH_LOG_FILE_COUNT, ls_attr.stats_.finish_log_file_count_, int64_t); char server_str[OB_MAX_SERVER_ADDR_SIZE] = { 0 }; int64_t port = 0; @@ -2065,9 +2087,15 @@ int ObBackupLSTaskOperator::update_stats( ObSqlString sql; int64_t affected_rows = -1; ObDMLSqlSplicer dml; + uint64_t data_version = 0; if (task_id <= 0 || tenant_id == OB_INVALID_TENANT_ID || !ls_id.is_valid() || !stats.is_valid()) { ret = OB_INVALID_ARGUMENT; LOG_WARN("[DATA_BACKUP]invalid argument", K(ret), K(task_id), K(tenant_id), K(ls_id), K(stats)); + } else if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, data_version))) { + LOG_WARN("failed to get min data version"); + } else if (data_version < DATA_VERSION_4_3_1_0) { + ret = OB_NOT_SUPPORTED; + LOG_WARN("VALUES STATEMENT is not supported", K(ret), K(data_version)); } else if (OB_FAIL(dml.add_pk_column(OB_STR_TENANT_ID, tenant_id))) { LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.add_pk_column(OB_STR_TASK_ID, task_id))) { @@ -2090,12 +2118,16 @@ int ObBackupLSTaskOperator::update_stats( LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.add_column(OB_STR_FILE_COUNT, stats.finish_file_count_))) { LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } else if (OB_FAIL(dml.add_column(OB_STR_LOG_FILE_COUNT, stats.log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); + } else if (OB_FAIL(dml.add_column(OB_STR_FINISH_LOG_FILE_COUNT, stats.finish_log_file_count_))) { + LOG_WARN("[DATA_BACKUP]failed to add column", K(ret)); } else if (OB_FAIL(dml.splice_update_sql(OB_ALL_BACKUP_LS_TASK_TNAME, sql))) { LOG_WARN("[DATA_BACKUP]failed to splice_update_sql", K(ret)); } else if (OB_FAIL(proxy.write(get_exec_tenant_id(tenant_id), sql.ptr(), affected_rows))) { LOG_WARN("[DATA_BACKUP]failed to exec sql", K(ret), K(sql)); } else { - LOG_INFO("[DATA_BACKUP]success update task type", K(sql)); + LOG_INFO("[DATA_BACKUP]success update stats", K(sql)); } return ret; } diff --git a/src/share/backup/ob_backup_struct.cpp b/src/share/backup/ob_backup_struct.cpp index 1c1dda68ba..2c21f80d10 100644 --- a/src/share/backup/ob_backup_struct.cpp +++ b/src/share/backup/ob_backup_struct.cpp @@ -2922,6 +2922,7 @@ const char* ObBackupStatus::get_str() const "BACKUP_DATA_SYS", "BACKUP_DATA_MINOR", "BACKUP_DATA_MAJOR", + "BEFORE_BACKUP_LOG", "BACKUP_LOG", }; @@ -2951,6 +2952,7 @@ int ObBackupStatus::set_status(const char *str) "BACKUP_DATA_SYS", "BACKUP_DATA_MINOR", "BACKUP_DATA_MAJOR", + "BEFORE_BACKUP_LOG", "BACKUP_LOG", }; const int64_t count = ARRAYSIZEOF(status_strs); @@ -3060,7 +3062,9 @@ bool ObBackupStats::is_valid() const && macro_block_count_ >= 0 && finish_macro_block_count_ >= 0 && extra_bytes_ >= 0 - && finish_file_count_ >= 0; + && finish_file_count_ >= 0 + && log_file_count_ >= 0 + && finish_log_file_count_ >= 0; } int ObBackupStats::assign(const ObBackupStats &other) @@ -3078,6 +3082,8 @@ int ObBackupStats::assign(const ObBackupStats &other) finish_macro_block_count_ = other.finish_macro_block_count_; extra_bytes_ = other.extra_bytes_; finish_file_count_ = other.finish_file_count_; + log_file_count_ = other.log_file_count_; + finish_log_file_count_ = other.finish_log_file_count_; } return ret; } @@ -3092,6 +3098,8 @@ void ObBackupStats::cum_with(const ObBackupStats &other) finish_macro_block_count_ += other.finish_macro_block_count_; extra_bytes_ += other.extra_bytes_; finish_file_count_ += other.finish_file_count_; + log_file_count_ += other.log_file_count_; + finish_log_file_count_ += other.finish_log_file_count_; } void ObBackupStats::reset() @@ -3104,6 +3112,8 @@ void ObBackupStats::reset() finish_macro_block_count_ = 0; extra_bytes_ = 0; finish_file_count_ = 0; + log_file_count_ = 0; + finish_log_file_count_ = 0; } ObHAResultInfo::ObHAResultInfo( @@ -3406,6 +3416,7 @@ const char* ObBackupDataTaskType::get_str() const "BACKUP_META_FINISH", "BACKUP_DATA_MINOR", "BACKUP_DATA_MAJOR", + "BEFORE_PLUS_ARCHIVE_LOG", "PLUS_ARCHIVE_LOG", "BUILD_INDEX" }; @@ -3426,6 +3437,7 @@ int ObBackupDataTaskType::set_type(const char *buf) "BACKUP_META_FINISH", "BACKUP_DATA_MINOR", "BACKUP_DATA_MAJOR", + "BEFORE_PLUS_ARCHIVE_LOG", "PLUS_ARCHIVE_LOG", "BUILD_INDEX", }; @@ -3508,8 +3520,9 @@ int ObBackupSetTaskAttr::assign(const ObBackupSetTaskAttr &other) LOG_WARN("failed to assign backup path", K(ret), K(other.backup_path_)); } else if (OB_FAIL(comment_.assign(other.comment_))) { LOG_WARN("failed to assign comment", K(ret)); + } else if (OB_FAIL(stats_.assign(other.stats_))) { + LOG_WARN("failed to assign stats", K(ret)); } else { - stats_.assign(other.stats_); incarnation_id_ = other.incarnation_id_; task_id_ = other.task_id_; tenant_id_ = other.tenant_id_; diff --git a/src/share/backup/ob_backup_struct.h b/src/share/backup/ob_backup_struct.h index 256ba3d376..3701cb40c8 100644 --- a/src/share/backup/ob_backup_struct.h +++ b/src/share/backup/ob_backup_struct.h @@ -312,6 +312,8 @@ const char *const OB_STR_MACRO_BLOCK_BYTES = "major_block_bytes"; const char *const OB_STR_FINISH_MACRO_BLOCK_BYTES = "finish_major_block_bytes"; const char *const OB_STR_MINOR_BLOCK_BYTES = "minor_block_bytes"; const char *const OB_STR_FINISH_MINOR_BLOCK_BYTES = "finish_minor_block_bytes"; +const char *const OB_STR_LOG_FILE_COUNT = "log_file_count"; +const char *const OB_STR_FINISH_LOG_FILE_COUNT = "finish_log_file_count"; const char *const OB_STR_START_REPLAY_LSN = "start_replay_lsn"; const char *const OB_STR_LAST_REPLAY_LSN = "last_replay_lsn"; @@ -1229,7 +1231,8 @@ public: BACKUP_DATA_SYS = 9, BACKUP_DATA_MINOR = 10, BACKUP_DATA_MAJOR = 11, - BACKUP_LOG = 12, + BEFORE_BACKUP_LOG = 12, + BACKUP_LOG = 13, MAX_STATUS }; ObBackupStatus(): status_(MAX_STATUS) {} @@ -1242,7 +1245,7 @@ public: bool is_backup_meta() const { return BACKUP_SYS_META == status_ || BACKUP_USER_META == status_; } bool is_backup_major() const { return BACKUP_DATA_MAJOR == status_; } bool is_backup_minor() const { return BACKUP_DATA_MINOR == status_; } - bool is_backup_log() const { return BACKUP_LOG == status_; } + bool is_backup_log() const { return BEFORE_BACKUP_LOG == status_ || BACKUP_LOG == status_; } bool is_backup_sys() const { return BACKUP_DATA_SYS == status_; } bool is_backup_finish() const { return COMPLETED == status_ || FAILED == status_ || CANCELED == status_; } const char* get_str() const; @@ -1300,7 +1303,8 @@ public: void cum_with(const ObBackupStats &other); void reset(); TO_STRING_KV(K_(input_bytes), K_(output_bytes), K_(tablet_count), K_(finish_tablet_count), - K_(macro_block_count), K_(finish_macro_block_count), K_(extra_bytes), K_(finish_file_count)); + K_(macro_block_count), K_(finish_macro_block_count), K_(extra_bytes), K_(finish_file_count), + K_(log_file_count), K_(finish_log_file_count)); int64_t input_bytes_; int64_t output_bytes_; int64_t tablet_count_; @@ -1445,8 +1449,9 @@ struct ObBackupDataTaskType final BACKUP_META_FINISH = 1, BACKUP_DATA_MINOR = 2, BACKUP_DATA_MAJOR = 3, - BACKUP_PLUS_ARCHIVE_LOG = 4, - BACKUP_BUILD_INDEX = 5, + BEFORE_PLUS_ARCHIVE_LOG = 4, + BACKUP_PLUS_ARCHIVE_LOG = 5, + BACKUP_BUILD_INDEX = 6, BACKUP_MAX }; ObBackupDataTaskType() : type_(Type::BACKUP_MAX) {} diff --git a/src/share/inner_table/ob_inner_table_schema.12201_12250.cpp b/src/share/inner_table/ob_inner_table_schema.12201_12250.cpp index be54c1dc8d..3d4eb9f54d 100644 --- a/src/share/inner_table/ob_inner_table_schema.12201_12250.cpp +++ b/src/share/inner_table/ob_inner_table_schema.12201_12250.cpp @@ -11100,6 +11100,44 @@ int ObInnerTableSchema::all_virtual_backup_task_schema(ObTableSchema &table_sche major_turn_id_default, major_turn_id_default); //default_value } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -11664,6 +11702,44 @@ int ObInnerTableSchema::all_virtual_backup_task_history_schema(ObTableSchema &ta major_turn_id_default, major_turn_id_default); //default_value } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -12235,6 +12311,44 @@ int ObInnerTableSchema::all_virtual_backup_ls_task_schema(ObTableSchema &table_s false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -12806,6 +12920,44 @@ int ObInnerTableSchema::all_virtual_backup_ls_task_history_schema(ObTableSchema false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); diff --git a/src/share/inner_table/ob_inner_table_schema.15201_15250.cpp b/src/share/inner_table/ob_inner_table_schema.15201_15250.cpp index 71fb0f4926..5b9c352a68 100644 --- a/src/share/inner_table/ob_inner_table_schema.15201_15250.cpp +++ b/src/share/inner_table/ob_inner_table_schema.15201_15250.cpp @@ -11309,6 +11309,36 @@ int ObInnerTableSchema::all_virtual_backup_task_ora_schema(ObTableSchema &table_ false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("LOG_FILE_COUNT", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("FINISH_LOG_FILE_COUNT", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -11803,6 +11833,36 @@ int ObInnerTableSchema::all_virtual_backup_task_history_ora_schema(ObTableSchema false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("LOG_FILE_COUNT", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } + + if (OB_SUCC(ret)) { + ADD_COLUMN_SCHEMA("FINISH_LOG_FILE_COUNT", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObNumberType, //column_type + CS_TYPE_INVALID, //column_collation_type + 38, //column_length + 38, //column_precision + 0, //column_scale + false, //is_nullable + false); //is_autoincrement + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); diff --git a/src/share/inner_table/ob_inner_table_schema.21151_21200.cpp b/src/share/inner_table/ob_inner_table_schema.21151_21200.cpp index abedd8dd4e..df234f2c74 100644 --- a/src/share/inner_table/ob_inner_table_schema.21151_21200.cpp +++ b/src/share/inner_table/ob_inner_table_schema.21151_21200.cpp @@ -260,7 +260,7 @@ int ObInnerTableSchema::cdb_ob_backup_tasks_schema(ObTableSchema &table_schema) table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())); if (OB_SUCC(ret)) { - if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN NULL ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH, MINOR_TURN_ID, MAJOR_TURN_ID, CASE WHEN MACRO_BLOCK_COUNT = 0 THEN 0.00 WHEN FINISH_MACRO_BLOCK_COUNT > MACRO_BLOCK_COUNT THEN 99.99 ELSE ROUND((FINISH_MACRO_BLOCK_COUNT / MACRO_BLOCK_COUNT) * 100, 2) END AS DATA_PROGRESS FROM OCEANBASE.__all_virtual_backup_task )__"))) { + if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN NULL ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH, MINOR_TURN_ID, MAJOR_TURN_ID, CASE WHEN MACRO_BLOCK_COUNT = 0 THEN 0.00 WHEN FINISH_MACRO_BLOCK_COUNT > MACRO_BLOCK_COUNT THEN 99.99 ELSE ROUND((FINISH_MACRO_BLOCK_COUNT / MACRO_BLOCK_COUNT) * 100, 2) END AS DATA_PROGRESS, LOG_FILE_COUNT, FINISH_LOG_FILE_COUNT, CASE WHEN LOG_FILE_COUNT = 0 THEN 0.00 WHEN FINISH_LOG_FILE_COUNT > LOG_FILE_COUNT THEN 99.99 ELSE ROUND((FINISH_LOG_FILE_COUNT / LOG_FILE_COUNT) * 100, 2) END AS LOG_PROGRESS FROM OCEANBASE.__all_virtual_backup_task )__"))) { LOG_ERROR("fail to set view_definition", K(ret)); } } diff --git a/src/share/inner_table/ob_inner_table_schema.351_400.cpp b/src/share/inner_table/ob_inner_table_schema.351_400.cpp index e6b1ede2ec..fd884710a4 100644 --- a/src/share/inner_table/ob_inner_table_schema.351_400.cpp +++ b/src/share/inner_table/ob_inner_table_schema.351_400.cpp @@ -3109,6 +3109,44 @@ int ObInnerTableSchema::all_backup_task_schema(ObTableSchema &table_schema) major_turn_id_default, major_turn_id_default); //default_value } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -3689,6 +3727,44 @@ int ObInnerTableSchema::all_backup_task_history_schema(ObTableSchema &table_sche major_turn_id_default, major_turn_id_default); //default_value } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -4276,6 +4352,44 @@ int ObInnerTableSchema::all_backup_ls_task_schema(ObTableSchema &table_schema) false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); @@ -4863,6 +4977,44 @@ int ObInnerTableSchema::all_backup_ls_task_history_schema(ObTableSchema &table_s false, //is_nullable false); //is_autoincrement } + + if (OB_SUCC(ret)) { + ObObj log_file_count_default; + log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + log_file_count_default, + log_file_count_default); //default_value + } + + if (OB_SUCC(ret)) { + ObObj finish_log_file_count_default; + finish_log_file_count_default.set_int(0); + ADD_COLUMN_SCHEMA_T("finish_log_file_count", //column_name + ++column_id, //column_id + 0, //rowkey_id + 0, //index_id + 0, //part_key_pos + ObIntType, //column_type + CS_TYPE_INVALID, //column_collation_type + sizeof(int64_t), //column_length + -1, //column_precision + -1, //column_scale + false, //is_nullable + false, //is_autoincrement + finish_log_file_count_default, + finish_log_file_count_default); //default_value + } table_schema.set_index_using_type(USING_BTREE); table_schema.set_row_store_type(ENCODING_ROW_STORE); table_schema.set_store_format(OB_STORE_FORMAT_DYNAMIC_MYSQL); diff --git a/src/share/inner_table/ob_inner_table_schema_def.py b/src/share/inner_table/ob_inner_table_schema_def.py index da39a6a85a..456c502531 100644 --- a/src/share/inner_table/ob_inner_table_schema_def.py +++ b/src/share/inner_table/ob_inner_table_schema_def.py @@ -3910,6 +3910,8 @@ def_table_schema( ('path', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'true', ''), ('minor_turn_id', 'int', 'false', '0'), ('major_turn_id', 'int', 'false', '0'), + ('log_file_count', 'int', 'false', '0'), + ('finish_log_file_count', 'int', 'false', '0'), ], ) def_table_schema( @@ -3953,6 +3955,8 @@ def_table_schema( ('path', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'true', ''), ('minor_turn_id', 'int', 'false', '0'), ('major_turn_id', 'int', 'false', '0'), + ('log_file_count', 'int', 'false', '0'), + ('finish_log_file_count', 'int', 'false', '0'), ], ) def_table_schema( @@ -3997,6 +4001,8 @@ def_table_schema( ('result', 'int', 'true', '0'), ('comment', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'true', ''), ('max_tablet_checkpoint_scn', 'uint'), + ('log_file_count', 'int', 'false', '0'), + ('finish_log_file_count', 'int', 'false', '0'), ], ) def_table_schema( @@ -4041,6 +4047,8 @@ def_table_schema( ('result', 'int', 'true', '0'), ('comment', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'true', ''), ('max_tablet_checkpoint_scn', 'uint'), + ('log_file_count', 'int', 'false', '0'), + ('finish_log_file_count', 'int', 'false', '0'), ], ) def_table_schema( @@ -18361,7 +18369,14 @@ def_table_schema( WHEN MACRO_BLOCK_COUNT = 0 THEN 0.00 WHEN FINISH_MACRO_BLOCK_COUNT > MACRO_BLOCK_COUNT THEN 99.99 ELSE ROUND((FINISH_MACRO_BLOCK_COUNT / MACRO_BLOCK_COUNT) * 100, 2) - END AS DATA_PROGRESS + END AS DATA_PROGRESS, + LOG_FILE_COUNT, + FINISH_LOG_FILE_COUNT, + CASE + WHEN LOG_FILE_COUNT = 0 THEN 0.00 + WHEN FINISH_LOG_FILE_COUNT > LOG_FILE_COUNT THEN 99.99 + ELSE ROUND((FINISH_LOG_FILE_COUNT / LOG_FILE_COUNT) * 100, 2) + END AS LOG_PROGRESS FROM OCEANBASE.__all_virtual_backup_task """.replace("\n", " ") ) diff --git a/src/share/ob_debug_sync_point.h b/src/share/ob_debug_sync_point.h index 160c58d9d6..401191e3ac 100755 --- a/src/share/ob_debug_sync_point.h +++ b/src/share/ob_debug_sync_point.h @@ -599,6 +599,7 @@ class ObString; ACT(HOLD_DDL_COMPLEMENT_DAG_BEFORE_REPORT_FINISH,)\ ACT(HOLD_DDL_COMPLEMENT_DAG_AFTER_REPORT_FINISH,)\ ACT(BEFORE_ALTER_TABLE_EXCHANGE_PARTITION,)\ + ACT(AFTER_REPORT_BACKUP_COMPL_LOG,)\ ACT(MAX_DEBUG_SYNC_POINT,) DECLARE_ENUM(ObDebugSyncPoint, debug_sync_point, OB_DEBUG_SYNC_POINT_DEF); diff --git a/src/share/ob_rpc_struct.cpp b/src/share/ob_rpc_struct.cpp index 059030e717..ab142931f2 100755 --- a/src/share/ob_rpc_struct.cpp +++ b/src/share/ob_rpc_struct.cpp @@ -7381,8 +7381,8 @@ bool ObBackupComplLogArg::is_valid() const && ls_id_.is_valid() && dst_server_.is_valid() && !backup_path_.is_empty() - && start_scn_.is_valid() - && end_scn_.is_valid(); + && start_scn_.is_valid_and_not_min() + && end_scn_.is_valid_and_not_min(); } int ObBackupComplLogArg::assign(const ObBackupComplLogArg &arg) diff --git a/src/storage/backup/ob_backup_handler.cpp b/src/storage/backup/ob_backup_handler.cpp index 4a6215b8f9..11bf6ec77e 100644 --- a/src/storage/backup/ob_backup_handler.cpp +++ b/src/storage/backup/ob_backup_handler.cpp @@ -182,7 +182,7 @@ int ObBackupHandler::schedule_build_tenant_level_index_dag(const ObBackupJobDesc int ObBackupHandler::schedule_backup_complement_log_dag(const ObBackupJobDesc &job_desc, const share::ObBackupDest &backup_dest, const uint64_t tenant_id, const share::ObBackupSetDesc &backup_set_desc, - const share::ObLSID &ls_id, const SCN &start_scn, const SCN &end_scn) + const share::ObLSID &ls_id, const SCN &start_scn, const SCN &end_scn, const bool is_only_calc_stat) { int ret = OB_SUCCESS; MAKE_TENANT_SWITCH_SCOPE_GUARD(guard); @@ -220,6 +220,7 @@ int ObBackupHandler::schedule_backup_complement_log_dag(const ObBackupJobDesc &j param.retry_id_ = 0; // retry id no use for complement log param.compl_start_scn_ = start_scn; param.compl_end_scn_ = end_scn; + param.is_only_calc_stat_ = is_only_calc_stat; param.report_ctx_ = report_ctx; if (OB_FAIL(param.backup_dest_.deep_copy(backup_dest))) { LOG_WARN("failed to deep copy backup dest", K(ret), K(backup_dest)); diff --git a/src/storage/backup/ob_backup_handler.h b/src/storage/backup/ob_backup_handler.h index 3296739f9c..69c82e5a9c 100644 --- a/src/storage/backup/ob_backup_handler.h +++ b/src/storage/backup/ob_backup_handler.h @@ -33,7 +33,7 @@ public: const int64_t turn_id, const int64_t retry_id, const share::ObBackupDataType &backup_data_type); static int schedule_backup_complement_log_dag(const ObBackupJobDesc &job_desc, const share::ObBackupDest &backup_dest, const uint64_t tenant_id, const share::ObBackupSetDesc &backup_set_desc, const share::ObLSID &ls_id, - const share::SCN &start_scn, const share::SCN &end_scn); + const share::SCN &start_scn, const share::SCN &end_scn, const bool is_only_calc_stat); }; } // namespace backup diff --git a/src/storage/backup/ob_backup_task.cpp b/src/storage/backup/ob_backup_task.cpp index 0853bca5da..7b70a3ce89 100644 --- a/src/storage/backup/ob_backup_task.cpp +++ b/src/storage/backup/ob_backup_task.cpp @@ -188,7 +188,8 @@ ObLSBackupDagNetInitParam::ObLSBackupDagNetInitParam() start_scn_(), backup_data_type_(), compl_start_scn_(), - compl_end_scn_() + compl_end_scn_(), + is_only_calc_stat_(false) {} ObLSBackupDagNetInitParam::~ObLSBackupDagNetInitParam() @@ -221,6 +222,7 @@ int ObLSBackupDagNetInitParam::assign(const ObLSBackupDagNetInitParam &other) backup_data_type_ = other.backup_data_type_; compl_start_scn_ = other.compl_start_scn_; compl_end_scn_ = other.compl_end_scn_; + is_only_calc_stat_ = other.is_only_calc_stat_; } return ret; } @@ -268,9 +270,10 @@ int ObLSBackupDagNetInitParam::convert_to(ObLSBackupDagInitParam &init_param) bool ObLSBackupDagNetInitParam::operator==(const ObLSBackupDagNetInitParam &other) const { - return job_desc_ == other.job_desc_ && backup_dest_ == other.backup_dest_ && tenant_id_ == other.tenant_id_ && - backup_set_desc_ == other.backup_set_desc_ && ls_id_ == other.ls_id_ && - turn_id_ == other.turn_id_ && retry_id_ == other.retry_id_ && dest_id_ == other.dest_id_; + return job_desc_ == other.job_desc_ && backup_dest_ == other.backup_dest_ && tenant_id_ == other.tenant_id_ + && backup_set_desc_ == other.backup_set_desc_ && ls_id_ == other.ls_id_ + && turn_id_ == other.turn_id_ && retry_id_ == other.retry_id_ && dest_id_ == other.dest_id_ + && is_only_calc_stat_ == other.is_only_calc_stat_; } /* ObLSBackupDagInitParam */ @@ -993,6 +996,7 @@ int ObLSBackupComplementLogDagNet::init_by_param(const share::ObIDagInitParam *p report_ctx_ = init_param.report_ctx_; compl_start_scn_ = init_param.compl_start_scn_; compl_end_scn_ = init_param.compl_end_scn_; + is_only_calc_stat_ = init_param.is_only_calc_stat_; is_inited_ = true; } return ret; @@ -1025,6 +1029,7 @@ int ObLSBackupComplementLogDagNet::start_running() param_.retry_id_, compl_start_scn_, compl_end_scn_, + is_only_calc_stat_, report_ctx_))) { LOG_WARN("failed to init child dag", K(ret), K_(param), K_(compl_start_scn), K_(compl_end_scn)); } else if (OB_FAIL(complement_dag->create_first_task())) { @@ -1836,6 +1841,7 @@ ObLSBackupComplementLogDag::ObLSBackupComplementLogDag() retry_id_(-1), compl_start_scn_(), compl_end_scn_(), + is_only_calc_stat_(false), report_ctx_() {} @@ -1845,7 +1851,7 @@ ObLSBackupComplementLogDag::~ObLSBackupComplementLogDag() int ObLSBackupComplementLogDag::init(const ObBackupJobDesc &job_desc, const ObBackupDest &backup_dest, const uint64_t tenant_id, const int64_t dest_id, const share::ObBackupSetDesc &backup_set_desc, const share::ObLSID &ls_id, const int64_t turn_id, const int64_t retry_id, const SCN &start_scn, const SCN &end_scn, - const ObBackupReportCtx &report_ctx) + const bool is_only_calc_stat, const ObBackupReportCtx &report_ctx) { int ret = OB_SUCCESS; if (IS_INIT) { @@ -1876,6 +1882,7 @@ int ObLSBackupComplementLogDag::init(const ObBackupJobDesc &job_desc, const ObBa compl_start_scn_ = start_scn; compl_end_scn_ = end_scn; report_ctx_ = report_ctx; + is_only_calc_stat_ = is_only_calc_stat; is_inited_ = true; } return ret; @@ -1888,7 +1895,7 @@ int ObLSBackupComplementLogDag::create_first_task() if (OB_FAIL(alloc_task(task))) { LOG_WARN("failed to alloc task", K(ret)); } else if (OB_FAIL(task->init(job_desc_, backup_dest_, tenant_id_, dest_id_, backup_set_desc_, ls_id_, compl_start_scn_, - compl_end_scn_, turn_id_, retry_id_, report_ctx_))) { + compl_end_scn_, turn_id_, retry_id_, is_only_calc_stat_, report_ctx_))) { LOG_WARN("failed to init task", K(ret), K_(tenant_id), K_(backup_set_desc), K_(ls_id), K_(compl_start_scn), K_(compl_end_scn)); } else if (OB_FAIL(add_task(*task))) { LOG_WARN("failed to add task", K(ret)); @@ -1932,7 +1939,7 @@ bool ObLSBackupComplementLogDag::operator==(const ObIDag &other) const const ObLSBackupComplementLogDag &other_dag = static_cast(other); bret = job_desc_ == other_dag.job_desc_ && backup_dest_ == other_dag.backup_dest_ && tenant_id_ == other_dag.tenant_id_ && dest_id_ == other_dag.dest_id_ && backup_set_desc_ == other_dag.backup_set_desc_ && - ls_id_ == other_dag.ls_id_; + ls_id_ == other_dag.ls_id_ && is_only_calc_stat_ == other_dag.is_only_calc_stat_; } return bret; } @@ -1945,6 +1952,7 @@ int64_t ObLSBackupComplementLogDag::hash() const hash_value = common::murmurhash(&tenant_id_, sizeof(tenant_id_), hash_value); hash_value = common::murmurhash(&backup_set_desc_, sizeof(backup_set_desc_), hash_value); hash_value = common::murmurhash(&ls_id_, sizeof(ls_id_), hash_value); + hash_value = common::murmurhash(&is_only_calc_stat_, sizeof(is_only_calc_stat_), hash_value); return hash_value; } @@ -4864,14 +4872,14 @@ ObLSBackupComplementLogTask::~ObLSBackupComplementLogTask() int ObLSBackupComplementLogTask::init(const ObBackupJobDesc &job_desc, const ObBackupDest &backup_dest, const uint64_t tenant_id, const int64_t dest_id, const share::ObBackupSetDesc &backup_set_desc, const share::ObLSID &ls_id, const SCN &start_scn, const SCN &end_scn, const int64_t turn_id, const int64_t retry_id, - const ObBackupReportCtx &report_ctx) + const bool is_only_calc_stat, const ObBackupReportCtx &report_ctx) { int ret = OB_SUCCESS; if (IS_INIT) { ret = OB_INIT_TWICE; LOG_WARN("ls backup complement log task init twice", K(ret)); } else if (!job_desc.is_valid() || !backup_dest.is_valid() || OB_INVALID_ID == tenant_id || - !backup_set_desc.is_valid() || !ls_id.is_valid() || !start_scn.is_valid() || !end_scn.is_valid()) { + !backup_set_desc.is_valid() || !ls_id.is_valid() || !start_scn.is_valid_and_not_min() || !end_scn.is_valid_and_not_min()) { ret = OB_INVALID_ARGUMENT; LOG_WARN("get invalid args", K(ret), @@ -4894,6 +4902,7 @@ int ObLSBackupComplementLogTask::init(const ObBackupJobDesc &job_desc, const ObB compl_end_scn_ = end_scn; turn_id_ = turn_id; retry_id_ = retry_id; + is_only_calc_stat_ = is_only_calc_stat; report_ctx_ = report_ctx; is_inited_ = true; } @@ -5005,8 +5014,16 @@ int ObLSBackupComplementLogTask::inner_process_( LOG_WARN("failed to make parent dir", K(ret), K(backup_path), K(backup_dest_)); } else if (OB_FAIL(calc_backup_file_range_(archive_dest_id, ls_id, file_list))) { LOG_WARN("failed to calc backup file range", K(ret), K(archive_dest_id), K(ls_id)); - } else if (OB_FAIL(backup_complement_log_(file_list))) { - LOG_WARN("failed to backup complement log", K(ret), K(file_list)); + } else { + if (is_only_calc_stat_) { + if (OB_FAIL(report_complement_log_stat_(file_list))) { + LOG_WARN("failed to report complement log stat", K(ret), K(file_list)); + } + } else { + if (OB_FAIL(backup_complement_log_(file_list))) { + LOG_WARN("failed to backup complement log", K(ret), K(file_list)); + } + } } return ret; } @@ -5472,6 +5489,60 @@ int ObLSBackupComplementLogTask::get_dst_backup_file_path_( return ret; } +int ObLSBackupComplementLogTask::update_ls_task_stat_(const share::ObBackupStats &old_backup_stat, + const int64_t compl_log_file_count, share::ObBackupStats &new_backup_stat) +{ + int ret = OB_SUCCESS; + new_backup_stat.input_bytes_ = old_backup_stat.input_bytes_; + new_backup_stat.output_bytes_ = old_backup_stat.output_bytes_; + new_backup_stat.tablet_count_ = old_backup_stat.tablet_count_; + new_backup_stat.macro_block_count_ = old_backup_stat.macro_block_count_; + new_backup_stat.finish_macro_block_count_ = old_backup_stat.finish_macro_block_count_; + new_backup_stat.finish_tablet_count_ = old_backup_stat.finish_tablet_count_; + new_backup_stat.finish_macro_block_count_ = new_backup_stat.finish_macro_block_count_; + new_backup_stat.log_file_count_ += compl_log_file_count; + return ret; +} + +int ObLSBackupComplementLogTask::report_complement_log_stat_(const common::ObIArray &file_list) +{ + int ret = OB_SUCCESS; + int tmp_ret = OB_SUCCESS; + const int64_t compl_log_file_count = file_list.count(); + ObMySQLTransaction trans; + int64_t max_file_id = 0; + const bool for_update = true; + const int64_t job_id = job_desc_.job_id_; + const int64_t task_id = job_desc_.task_id_; + const uint64_t tenant_id = tenant_id_; + const share::ObLSID &ls_id = ls_id_; + if (OB_FAIL(trans.start(report_ctx_.sql_proxy_, gen_meta_tenant_id(tenant_id)))) { + LOG_WARN("failed to start transaction", K(ret)); + } else { + share::ObBackupLSTaskAttr old_ls_task_attr; + share::ObBackupStats new_ls_task_stat; + if (OB_FAIL(ObBackupLSTaskOperator::get_ls_task(trans, for_update, + task_id, tenant_id, ls_id, old_ls_task_attr))) { + LOG_WARN("failed to get ls task", K(ret)); + } else if (OB_FAIL(update_ls_task_stat_(old_ls_task_attr.stats_, compl_log_file_count, new_ls_task_stat))) { + LOG_WARN("failed to update ls task stat", K(ret)); + } else if (OB_FAIL(ObBackupLSTaskOperator::update_stats(trans, task_id, tenant_id, ls_id, new_ls_task_stat))) { + LOG_WARN("failed to update stat", K(ret)); + } + + if (OB_SUCC(ret)) { + if (OB_FAIL(trans.end(true /*commit*/))) { + LOG_WARN("failed to commit", K(ret)); + } + } else { + if (OB_TMP_FAIL(trans.end(false /* commit*/))) { + LOG_WARN("failed to rollback trans", K(tmp_ret)); + } + } + } + return ret; +} + int ObLSBackupComplementLogTask::backup_complement_log_(const common::ObIArray &src_file_list) { int ret = OB_SUCCESS; @@ -5508,7 +5579,9 @@ int ObLSBackupComplementLogTask::backup_complement_log_(const common::ObIArray &list); int backup_complement_log_(const common::ObIArray &path); int inner_backup_complement_log_(const share::ObBackupPath &src_path, const share::ObBackupPath &dst_path); int transfer_clog_file_(const share::ObBackupPath &src_path, const share::ObBackupPath &dst_path); @@ -749,7 +758,7 @@ private: int64_t turn_id_; int64_t retry_id_; share::ObBackupDest archive_dest_; - + bool is_only_calc_stat_; ObBackupReportCtx report_ctx_; DISALLOW_COPY_AND_ASSIGN(ObLSBackupComplementLogTask); }; diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result index 0a5d5bdca8..e55a1c362c 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_sys_views_in_sys.result @@ -2130,6 +2130,9 @@ PATH varchar(4096) YES MINOR_TURN_ID bigint(20) NO MAJOR_TURN_ID bigint(20) NO DATA_PROGRESS decimal(26,2) NO +LOG_FILE_COUNT bigint(20) NO +FINISH_LOG_FILE_COUNT bigint(20) NO +LOG_PROGRESS decimal(26,2) NO select /*+QUERY_TIMEOUT(60000000)*/ count(*) as cnt from (select * from oceanbase.CDB_OB_BACKUP_TASKS limit 1); cnt 1 diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result index a520adf91b..3db1c694c0 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_mysql.result @@ -2432,6 +2432,8 @@ comment varchar(4096) YES path varchar(4096) YES minor_turn_id bigint(20) NO 0 major_turn_id bigint(20) NO 0 +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_task; IF(count(*) >= 0, 1, 0) 1 @@ -2467,6 +2469,8 @@ comment varchar(4096) YES path varchar(4096) YES minor_turn_id bigint(20) NO 0 major_turn_id bigint(20) NO 0 +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_task_history; IF(count(*) >= 0, 1, 0) 1 diff --git a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result index ca9171858e..fedd05ddad 100644 --- a/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result +++ b/tools/deploy/mysql_test/test_suite/inner_table/r/mysql/desc_virtual_table_in_sys.result @@ -5604,6 +5604,8 @@ comment varchar(4096) YES path varchar(4096) YES minor_turn_id bigint(20) NO 0 major_turn_id bigint(20) NO 0 +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_task; IF(count(*) >= 0, 1, 0) 1 @@ -5639,6 +5641,8 @@ comment varchar(4096) YES path varchar(4096) YES minor_turn_id bigint(20) NO 0 major_turn_id bigint(20) NO 0 +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_task_history; IF(count(*) >= 0, 1, 0) 1 @@ -5675,6 +5679,8 @@ retry_id bigint(20) YES 0 result bigint(20) YES 0 comment varchar(4096) YES max_tablet_checkpoint_scn bigint(20) unsigned NO NULL +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_ls_task; IF(count(*) >= 0, 1, 0) 1 @@ -5711,6 +5717,8 @@ retry_id bigint(20) YES 0 result bigint(20) YES 0 comment varchar(4096) YES max_tablet_checkpoint_scn bigint(20) unsigned NO NULL +log_file_count bigint(20) NO 0 +finish_log_file_count bigint(20) NO 0 select /*+QUERY_TIMEOUT(60000000)*/ IF(count(*) >= 0, 1, 0) from oceanbase.__all_virtual_backup_ls_task_history; IF(count(*) >= 0, 1, 0) 1