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

Upgrade compatibility of backup and restore

Browse Source
This commit is contained in:
hamstersox 2023-03-04 07:11:08 +00:00 committed by ob-robot
parent 5cd4dcc8b4
commit 59fe65cfe2
20 changed files with 418 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
src/rootserver/backup/ob_backup_data_scheduler.cpp
View File

@ -610,10 +610,15 @@ int ObBackupDataScheduler::start_tenant_backup_data_(const ObBackupJobAttr &job_
LOG_WARN("log archive is not doing, can't start backup", K(ret));
} else {
ObMySQLTransaction trans;
if (OB_FAIL(trans.start(sql_proxy_, gen_meta_tenant_id(new_job_attr.tenant_id_)))) {
uint64_t cluster_version = 0;
if (OB_FAIL(ObShareUtil::fetch_current_cluster_version(*sql_proxy_, cluster_version))) {
LOG_WARN("failed to get cluster version", K(ret));
} else if (OB_FAIL(trans.start(sql_proxy_, gen_meta_tenant_id(new_job_attr.tenant_id_)))) {
LOG_WARN("[DATA_BACKUP]failed to start trans", K(ret), K(job_attr));
} else {
if (OB_FAIL(get_next_job_id(trans, new_job_attr.tenant_id_, new_job_attr.job_id_))) {
if (OB_FAIL(persist_backup_version_(trans, new_job_attr.tenant_id_, cluster_version))) {
LOG_WARN("failed to persist backup version", K(ret));
} else if (OB_FAIL(get_next_job_id(trans, new_job_attr.tenant_id_, new_job_attr.job_id_))) {
LOG_WARN("[DATA_BACKUP]failed to get next job id", K(ret));
} else if (OB_FAIL(get_next_backup_set_id(trans, new_job_attr.tenant_id_, new_job_attr.backup_set_id_))) {
LOG_WARN("[DATA_BACKUP]failed to get next backup set id", K(ret));
@ -647,29 +652,81 @@ int ObBackupDataScheduler::start_tenant_backup_data_(const ObBackupJobAttr &job_
return ret;
}
int ObBackupDataScheduler::get_scn(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, SCN &scn)
int ObBackupDataScheduler::persist_backup_version_(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, const uint64_t &cluster_version)
{
int ret = OB_SUCCESS;
uint64_t data_version = 0;
uint64_t exec_tenant_id = gen_meta_tenant_id(tenant_id);
if (GCONF.enable_upgrade_mode) {
ret = OB_BACKUP_CAN_NOT_START;
LOG_USER_ERROR(OB_BACKUP_CAN_NOT_START, "cluster upgrading");
LOG_WARN("cluster upgrade, can't start backup", K(ret), K(tenant_id));
} else if (OB_FAIL(ObShareUtil::fetch_current_data_version(sql_proxy, exec_tenant_id, data_version))) {
LOG_WARN("failed to get data version", K(ret), K(exec_tenant_id));
} else if (OB_FAIL(ObLSBackupInfoOperator::set_backup_version(sql_proxy, exec_tenant_id, data_version))) {
LOG_WARN("failed to set backup version", K(ret), K(exec_tenant_id), K(data_version));
} else if (OB_FAIL(ObLSBackupInfoOperator::set_cluster_version(sql_proxy, exec_tenant_id, cluster_version))) {
LOG_WARN("failed to set set cluster version", K(ret), K(exec_tenant_id));
}
return ret;
}
int ObBackupDataScheduler::get_backup_scn(
common::ObISQLClient &sql_proxy, const uint64_t tenant_id, const bool is_start, SCN &scn)
{
int ret = OB_SUCCESS;
ObAllTenantInfo tenant_info;
const bool for_update = false;
if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(tenant_id, &sql_proxy, for_update, tenant_info))) {
ObMySQLTransaction trans;
const uint64_t exec_tenant_id = gen_meta_tenant_id(tenant_id);
if (OB_FAIL(trans.start(&sql_proxy, exec_tenant_id))) {
LOG_WARN("failed to start trans", K(ret), K(exec_tenant_id));
} else if (OB_FAIL(ObAllTenantInfoProxy::load_tenant_info(tenant_id, &trans, true/*for update*/, tenant_info))) {
LOG_WARN("failed to get tenant info", K(ret), K(tenant_id));
} else {
// TODO when provide the scn_to_str, remove this .
// The conversion accuracy of SCN to time_stamp is inconsistent under MySQL mode and Oracle mode.
// The conversion accuracy in ORALCE mode is nanosecond, but it is microsecond in mysql
// for backup and restore, we keep the scn round up to microseconds that keep the conversion accuracy is consistent.
// meanwhile, in order to solve that boundary is not included in the restore, scn + 1;
// 1658475549197665190 --> 1658475549197666000
SCN tmp_scn;
int64_t ts;
ts = tenant_info.get_standby_scn().convert_to_ts();
if (OB_FAIL(tmp_scn.convert_from_ts(ts))) {
LOG_WARN("fail to convert from ts", K(ret), K(ts));
} else if (tenant_info.get_standby_scn() != tmp_scn && OB_FAIL(tmp_scn.convert_from_ts(ts + 1))) {
LOG_WARN("fail to convert from ts", K(ret), K(ts));
if (tenant_info.is_primary()) {
// for parmary tenant, the backup start scn get from gts as the same as end scn.
if (OB_FAIL(ObBackupUtils::get_backup_scn(tenant_id, tmp_scn))) {
LOG_WARN("failed to get gts", K(ret), K(tenant_id));
}
} else if (tenant_info.is_standby()) {
// for standby tenant, the backup start scn must be the readable scn, so it get from sts.
// but end scn must be replayable scn, so it get from the tenant_info.
if (is_start) {
if (OB_FAIL(ObBackupUtils::get_backup_scn(tenant_id, tmp_scn))) {
LOG_WARN("failed to get gts", K(ret), K(tenant_id));
}
} else {
tmp_scn = tenant_info.get_replayable_scn();
}
} else {
scn = tmp_scn;
ret = OB_STATE_NOT_MATCH;
LOG_WARN("tenant role not match", K(ret), K(tenant_info));
}
if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) {
LOG_WARN("failed to commit", K(ret));
} else {
// TODO when provide the scn_to_str, remove this .
// The conversion accuracy of SCN to time_stamp is inconsistent under MySQL mode and Oracle mode.
// The conversion accuracy in ORALCE mode is nanosecond, but it is microsecond in mysql
// for backup and restore, we keep the scn round up to microseconds that keep the conversion accuracy is consistent.
// meanwhile, in order to solve that boundary is not included in the restore, scn + 1;
// 1658475549197665190 --> 1658475549197666000
int64_t ts = 0;
ts = tmp_scn.convert_to_ts();
if (OB_FAIL(scn.convert_from_ts(ts))) {
LOG_WARN("fail to convert from ts", K(ret), K(ts));
} else if (tmp_scn != scn && OB_FAIL(scn.convert_from_ts(ts + 1))) {
LOG_WARN("fail to convert from ts", K(ret), K(ts));
}
}
} else {
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS != (tmp_ret = trans.end(false))) {
LOG_WARN("failed to roll back", K(ret), K(tmp_ret));
}
}
}
return ret;
@ -1227,8 +1284,23 @@ int ObUserTenantBackupJobMgr::report_failed_to_initiator_()
int ObUserTenantBackupJobMgr::check_can_backup_()
{
int ret = OB_SUCCESS;
uint64_t data_version = 0;
uint64_t cluster_version = 0;
uint64_t exec_tenant_id = gen_meta_tenant_id(job_attr_->tenant_id_);
if (share::ObBackupStatus::CANCELING == job_attr_->status_.status_) {
// backup job is canceling, no need to check log archive status
} else if (GCONF.enable_upgrade_mode) {
ret = OB_STATE_NOT_MATCH;
LOG_WARN("cluster is upgrade, backup can't continue", K(ret), KPC(job_attr_));
} else if (OB_FAIL(share::ObLSBackupInfoOperator::get_backup_version(*sql_proxy_, exec_tenant_id, data_version))) {
LOG_WARN("failed to get backup version", K(ret), K(exec_tenant_id));
} else if (OB_FAIL(share::ObLSBackupInfoOperator::get_cluster_version(*sql_proxy_, exec_tenant_id, cluster_version))) {
LOG_WARN("failed to get cluster version", K(ret), K(exec_tenant_id));
} else if (cluster_version != GET_MIN_CLUSTER_VERSION()) {
ret = OB_VERSION_NOT_MATCH;
LOG_WARN("cluster version not match, backup can't continue", K(ret), K(cluster_version));
} else if (OB_FAIL(ObBackupUtils::check_tenant_data_version_match(exec_tenant_id, data_version))) {
LOG_WARN("failed to check tenant data version", K(ret), K(exec_tenant_id), K(data_version));
} else {
ObTenantArchiveRoundAttr round_attr;
if (OB_FAIL(ObTenantArchiveMgr::get_tenant_current_round(job_attr_->tenant_id_, job_attr_->incarnation_id_, round_attr))) {
@ -1403,7 +1475,8 @@ int ObUserTenantBackupJobMgr::insert_backup_set_task_(common::ObISQLClient &sql_
LOG_WARN("[DATA_BACKUP]failed to assign backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(get_next_task_id_(sql_proxy, backup_set_task.task_id_))) {
LOG_WARN("[DATA_BACKUP]failed to get next task id", K(ret));
} else if (OB_FAIL(ObBackupDataScheduler::get_scn(sql_proxy, job_attr_->tenant_id_, backup_set_task.start_scn_))) {
} else if (OB_FAIL(ObBackupDataScheduler::get_backup_scn(
sql_proxy, job_attr_->tenant_id_, true/*start scn*/, backup_set_task.start_scn_))) {
LOG_WARN("fail t get start scn", K(ret));
} else {
backup_set_task.tenant_id_ = job_attr_->tenant_id_;
@ -1461,6 +1534,8 @@ int ObUserTenantBackupJobMgr::fill_backup_set_desc_(
ObBackupSetFileDesc &backup_set_desc)
{
int ret = OB_SUCCESS;
uint64_t data_version = 0;
uint64_t cluster_version = 0;
if (!job_attr.is_valid() || prev_inc_backup_set_id < 0 || prev_full_backup_set_id < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("[DATA_BACKUP]invalid argument", K(ret), K(job_attr), K(prev_inc_backup_set_id), K(prev_full_backup_set_id));
@ -1470,6 +1545,10 @@ int ObUserTenantBackupJobMgr::fill_backup_set_desc_(
LOG_WARN("[DATA_BACKUP]failed to assign passwd", K(ret));
} else if (OB_FAIL(backup_set_desc.backup_path_.assign(job_attr.backup_path_))) {
LOG_WARN("[DATA_BACKUP]failed to assign backup dest", K(ret));
} else if (OB_FAIL(ObShareUtil::fetch_current_data_version(*sql_proxy_, job_attr.tenant_id_, data_version))) {
LOG_WARN("failed to get min data version", K(ret));
} else if (OB_FAIL(ObShareUtil::fetch_current_cluster_version(*sql_proxy_, cluster_version))) {
LOG_WARN("failed to get cluster version", K(ret));
} else {
backup_set_desc.backup_set_id_ = job_attr.backup_set_id_;
backup_set_desc.tenant_id_ = job_attr.tenant_id_;
@ -1487,8 +1566,9 @@ int ObUserTenantBackupJobMgr::fill_backup_set_desc_(
backup_set_desc.encryption_mode_ = job_attr.encryption_mode_;
backup_set_desc.start_replay_scn_ = SCN::min_scn();
backup_set_desc.min_restore_scn_ = SCN::min_scn();
backup_set_desc.backup_compatible_ = ObBackupSetFileDesc::Compatible::COMPATIBLE_VERSION_1;
backup_set_desc.tenant_compatible_ = GET_MIN_CLUSTER_VERSION();
backup_set_desc.backup_compatible_ = ObBackupSetFileDesc::Compatible::COMPATIBLE_VERSION_2;
backup_set_desc.tenant_compatible_ = data_version;
backup_set_desc.cluster_version_ = cluster_version;
backup_set_desc.plus_archivelog_ = job_attr.plus_archivelog_;
}
return ret;

3
src/rootserver/backup/ob_backup_data_scheduler.h
View File

@ -53,7 +53,7 @@ public:
virtual int get_need_reload_task(common::ObIAllocator &allocator, common::ObIArray<ObBackupScheduleTask *> &tasks) override;
public:
// common func used by backup
static int get_scn(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, share::SCN &scn);
static int get_backup_scn(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, const bool is_start, share::SCN &scn);
static int check_tenant_status(share::schema::ObMultiVersionSchemaService &schema_service, uint64_t tenant_id, bool &is_valid);
static int get_backup_path(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, share::ObBackupPathString &backup_path);
static int get_next_job_id(common::ObISQLClient &trans, const uint64_t tenant_id, int64_t &job_id);
@ -91,6 +91,7 @@ private:
const share::ObBackupLSTaskAttr &ls_task,
ObIAllocator &allocator, ObBackupScheduleTask *&task);
int persist_backup_version_(common::ObISQLClient &sql_proxy, const uint64_t tenant_id, const uint64_t &cluster_version);
template <typename T>
int do_build_task_(const share::ObBackupJobAttr &job, const share::ObBackupSetTaskAttr &set_task_attr,
const share::ObBackupLSTaskAttr &ls_task,

22
src/rootserver/backup/ob_backup_data_set_task_mgr.cpp
View File

@ -867,7 +867,7 @@ int ObBackupSetTaskMgr::backup_data_()
} else if (OB_FAIL(trans_.start(sql_proxy_, meta_tenant_id_))) {
LOG_WARN("fail to start trans", K(ret));
} else {
if (OB_FAIL(ObBackupDataScheduler::get_scn(*sql_proxy_, job_attr_->tenant_id_, end_scn))) {
if (OB_FAIL(ObBackupDataScheduler::get_backup_scn(*sql_proxy_, job_attr_->tenant_id_, false/*end scn*/, end_scn))) {
LOG_WARN("[DATA_BACKUP]failed to get end ts", K(ret), "tenant_id", job_attr_->tenant_id_);
} else if (OB_FAIL(build_index_(build_index_attr, set_task_attr_.data_turn_id_, set_task_attr_.task_id_, finish_build_index))) {
LOG_WARN("[DATA_BACKUP]failed to wait build index", K(ret), K(set_task_attr_), KPC(build_index_attr));
@ -1604,19 +1604,29 @@ int ObBackupSetTaskMgr::write_backup_set_info_(
{
int ret = OB_SUCCESS;
int64_t dest_id = 0;
uint64_t cluster_version = GET_MIN_CLUSTER_VERSION();
ObBackupSetFileDesc &backup_set_file = backup_set_info.backup_set_file_;
ObBackupDest backup_dest;
if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_, set_task_attr.backup_path_, backup_dest))) {
uint64_t cur_data_version = 0;
uint64_t cur_cluster_version = 0;
if (OB_FAIL(ObShareUtil::fetch_current_data_version(*sql_proxy_, job_attr_->tenant_id_, cur_data_version))) {
LOG_WARN("failed to get data version", K(ret));
} else if (OB_FAIL(ObShareUtil::fetch_current_cluster_version(*sql_proxy_, cur_cluster_version))) {
LOG_WARN("failed to get cluster version", K(ret));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_backup_dest(*sql_proxy_, job_attr_->tenant_id_, set_task_attr.backup_path_, backup_dest))) {
LOG_WARN("[DATA_BACKUP]fail to get backup dest", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupStorageInfoOperator::get_dest_id(*sql_proxy_, job_attr_->tenant_id_, backup_dest, dest_id))) {
LOG_WARN("[DATA_BACKUP]failed to get dest id", K(ret), KPC(job_attr_));
} else if (OB_FAIL(ObBackupSetFileOperator::get_backup_set_file(*sql_proxy_, false/*for update*/, job_attr_->backup_set_id_, job_attr_->incarnation_id_,
job_attr_->tenant_id_, dest_id, backup_set_file))) {
LOG_WARN("[DATA_BACKUP]failed to get backup set", K(ret), KPC(job_attr_));
} else if (cluster_version != backup_set_file.tenant_compatible_) {
ret = OB_NOT_SUPPORTED;
LOG_WARN("[DATA_BACKUP]when cluster_version change, backup can't continue", K(ret), K(cluster_version), K(backup_set_file.tenant_compatible_));
} else if (cur_data_version != backup_set_file.tenant_compatible_ || cur_cluster_version != backup_set_file.cluster_version_) {
ret = OB_VERSION_NOT_MATCH;
LOG_WARN("cluster version or tenant data version are not match", K(ret),
K(cur_data_version),
"backup_data_version", backup_set_file.tenant_compatible_,
K(cur_cluster_version),
"backup_cluster_version", backup_set_file.cluster_version_);
} else {
backup_set_file.backup_set_id_ = job_attr_->backup_set_id_;
backup_set_file.incarnation_ = job_attr_->incarnation_id_;

3
src/rootserver/restore/ob_restore_scheduler.cpp
View File

@ -343,8 +343,7 @@ int ObRestoreService::fill_create_tenant_arg(
arg.if_not_exist_ = false;
arg.is_restore_ = true;
arg.recovery_until_scn_ = job.get_restore_scn();
//TODO(chongrong.th): should change to tenant's data version
arg.compatible_version_ = job.get_source_cluster_version();
arg.compatible_version_ = job.get_source_data_version();
if (OB_FAIL(assign_pool_list(pool_list.ptr(), arg.pool_list_))) {
LOG_WARN("fail to get pool list", K(ret), K(pool_list));
}

40
src/rootserver/restore/ob_restore_util.cpp
View File

@ -27,6 +27,7 @@
#include "logservice/palf/palf_base_info.h"//PalfBaseInfo
#include "storage/backup/ob_backup_extern_info_mgr.h"//ObExternLSMetaMgr
#include "storage/ls/ob_ls_meta_package.h"//ls_meta
#include "share/ob_upgrade_utils.h"
using namespace oceanbase::common;
using namespace oceanbase;
@ -545,12 +546,15 @@ int ObRestoreUtil::do_fill_backup_info_(
} else if (!backup_set_info.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid backup set file", K(ret), K(backup_set_info));
} else if (OB_FAIL(check_backup_set_version_match_(backup_set_info.backup_set_file_))) {
LOG_WARN("failed to check backup set version match", K(ret));
} else if (OB_FAIL(job.set_backup_tenant_name(locality_info.tenant_name_.ptr()))) {
LOG_WARN("fail to set backup tenant name", K(ret), "tenant name", locality_info.tenant_name_);
} else if (OB_FAIL(job.set_backup_cluster_name(locality_info.cluster_name_.ptr()))) {
LOG_WARN("fail to set backup cluster name", K(ret), "cluster name", locality_info.cluster_name_);
} else {
job.set_source_cluster_version(backup_set_info.backup_set_file_.tenant_compatible_);
job.set_source_data_version(backup_set_info.backup_set_file_.tenant_compatible_);
job.set_source_cluster_version(backup_set_info.backup_set_file_.cluster_version_);
job.set_compat_mode(locality_info.compat_mode_);
job.set_backup_tenant_id(backup_set_info.backup_set_file_.tenant_id_);
}
@ -558,6 +562,40 @@ int ObRestoreUtil::do_fill_backup_info_(
return ret;
}
int ObRestoreUtil::check_backup_set_version_match_(share::ObBackupSetFileDesc &backup_file_desc)
{
int ret = OB_SUCCESS;
uint64_t data_version = 0;
if (!backup_file_desc.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(backup_file_desc));
} else if (CLUSTER_VERSION_4_0_0_0 > backup_file_desc.cluster_version_
|| CLUSTER_VERSION_4_1_0_0 < backup_file_desc.cluster_version_) { // TODO(chongrong.th) wait yanmu provide the check cluster version exist interface
ret = OB_INVALID_ARGUMENT;
LOG_WARN("data version are not exist", K(ret));
LOG_USER_ERROR(OB_INVALID_ARGUMENT, "cluster version of backup set");
} else if (!ObUpgradeChecker::check_data_version_exist(backup_file_desc.tenant_compatible_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("data version are not exist", K(ret));
LOG_USER_ERROR(OB_INVALID_ARGUMENT, "tenant compatible of backup set");
} else if (GET_MIN_CLUSTER_VERSION() < backup_file_desc.cluster_version_) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("restore from higher cluster version is not allowed", K(ret));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "restore from higher cluster version is");
} else if (OB_FAIL(ObUpgradeChecker::get_data_version_by_cluster_version(GET_MIN_CLUSTER_VERSION(), data_version))) {
LOG_WARN("failed to get data version", K(ret));
} else if (data_version < backup_file_desc.tenant_compatible_) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("restore from higher data version is not allowed", K(ret), K(data_version), K(backup_file_desc.tenant_compatible_));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "restore from higher data version is");
} else if (backup_file_desc.tenant_compatible_ < DATA_VERSION_4_1_0_0 && data_version >= DATA_VERSION_4_1_0_0) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("restore from version 4.0 is not allowd", K(ret), K(backup_file_desc.tenant_compatible_), K(data_version));
LOG_USER_ERROR(OB_OP_NOT_ALLOW, "restore from version 4.0 is");
}
return ret;
}
int ObRestoreUtil::recycle_restore_job(const uint64_t tenant_id,
common::ObMySQLProxy &sql_proxy,
const ObPhysicalRestoreJob &job_info)

1
src/rootserver/restore/ob_restore_util.h
View File

@ -108,6 +108,7 @@ private:
static int do_fill_backup_info_(
const share::ObBackupSetPath & backup_set_path,
share::ObPhysicalRestoreJob &job);
static int check_backup_set_version_match_(share::ObBackupSetFileDesc &backup_file_desc);
static int get_encrypt_backup_dest_format_str(
const ObArray<ObString> &original_dest_list,
common::ObArenaAllocator &allocator,

87
src/share/backup/ob_backup_data_table_operator.cpp
View File

@ -63,8 +63,12 @@ int ObBackupSetFileOperator::fill_dml_with_backup_set_(const ObBackupSetFileDesc
{
int ret = OB_SUCCESS;
char tenant_version_display[OB_INNER_TABLE_BACKUP_TASK_CLUSTER_FORMAT_LENGTH] = "";
char cluster_version_display[OB_INNER_TABLE_BACKUP_TASK_CLUSTER_FORMAT_LENGTH] = "";
const int64_t pos = ObClusterVersion::get_instance().print_version_str(
tenant_version_display, OB_INNER_TABLE_BACKUP_TASK_CLUSTER_FORMAT_LENGTH, backup_set_desc.tenant_compatible_);
const int64_t pos1 = ObClusterVersion::get_instance().print_version_str(
cluster_version_display, OB_INNER_TABLE_BACKUP_TASK_CLUSTER_FORMAT_LENGTH, backup_set_desc.cluster_version_);
const char *comment = OB_SUCCESS == backup_set_desc.result_ ? "" : common::ob_strerror(backup_set_desc.result_);
if (OB_FAIL(dml.add_pk_column(OB_STR_BACKUP_SET_ID, backup_set_desc.backup_set_id_))) {
LOG_WARN("[DATA_BACKUP]failed to add column", K(ret));
@ -98,6 +102,8 @@ int ObBackupSetFileOperator::fill_dml_with_backup_set_(const ObBackupSetFileDesc
LOG_WARN("[DATA_BACKUP]failed to add column", K(ret));
} else if (OB_FAIL(dml.add_column(OB_STR_TENANT_COMPATIBLE, tenant_version_display))) {
LOG_WARN("[DATA_BACKUP]failed to add column", K(ret));
} else if (OB_FAIL(dml.add_column(OB_STR_CLUSTER_VERSION, cluster_version_display))) {
LOG_WARN("[DATA_BACKUP]failed to add column", K(ret));
} else if (OB_FAIL(dml.add_column(OB_STR_BACKUP_COMPATIBLE, backup_set_desc.backup_compatible_))) {
LOG_WARN("[DATA_BACKUP]failed to add column", K(ret));
} else if (OB_FAIL(dml.add_uint64_column(OB_STR_START_REPLAY_SCN, backup_set_desc.start_replay_scn_.get_val_for_inner_table_field()))) {
@ -312,6 +318,7 @@ int ObBackupSetFileOperator::do_parse_backup_set_(ObMySQLResult &result, ObBacku
char passwd[OB_MAX_PASSWORD_LENGTH] = "";
char backup_type_str[OB_SYS_TASK_TYPE_LENGTH] = "";
char tenant_version_str[OB_CLUSTER_VERSION_LENGTH] = "";
char cluster_version_str[OB_CLUSTER_VERSION_LENGTH] = "";
char file_status_str[OB_DEFAULT_STATUS_LENTH] = "";
char status_str[OB_DEFAULT_STATUS_LENTH] = "";
char plus_archivelog_str[OB_DEFAULT_STATUS_LENTH] = "";
@ -342,6 +349,7 @@ int ObBackupSetFileOperator::do_parse_backup_set_(ObMySQLResult &result, ObBacku
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_BACKUP_PASSWD, passwd, OB_MAX_PASSWORD_LENGTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_PATH, backup_path, OB_MAX_BACKUP_DEST_LENGTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_TENANT_COMPATIBLE, tenant_version_str, OB_CLUSTER_VERSION_LENGTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_CLUSTER_VERSION, cluster_version_str, OB_CLUSTER_VERSION_LENGTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_FILE_STATUS, file_status_str, OB_DEFAULT_STATUS_LENTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_STATUS, status_str, OB_DEFAULT_STATUS_LENTH, real_length);
EXTRACT_STRBUF_FIELD_MYSQL(result, OB_STR_BACKUP_PLUS_ARCHIVELOG, plus_archivelog_str, OB_DEFAULT_STATUS_LENTH, real_length);
@ -355,7 +363,9 @@ int ObBackupSetFileOperator::do_parse_backup_set_(ObMySQLResult &result, ObBacku
} else if (OB_FAIL(backup_set_desc.backup_type_.set_backup_type(backup_type_str))) {
LOG_WARN("[DATA_BACKUP]failed to set backup_type", K(ret), K(backup_type_str));
} else if (OB_FAIL(ObClusterVersion::get_version(tenant_version_str, backup_set_desc.tenant_compatible_))) {
LOG_WARN("[DATA_BACKUP]failed to parse cluster version", K(ret), K(tenant_version_str));
LOG_WARN("[DATA_BACKUP]failed to parse tenant version", K(ret), K(tenant_version_str));
} else if (OB_FAIL(ObClusterVersion::get_version(cluster_version_str, backup_set_desc.cluster_version_))) {
LOG_WARN("[DATA_BACKUP]failed to parse cluster version", K(ret), K(cluster_version_str));
} else if (OB_FAIL(backup_set_desc.set_backup_set_status(status_str))) {
LOG_WARN("[DATA_BACKUP]failed to parse status", K(ret), K(status_str));
} else if (OB_FAIL(backup_set_desc.set_plus_archivelog(plus_archivelog_str))) {
@ -2580,6 +2590,64 @@ int ObLSBackupInfoOperator::get_next_dest_id(common::ObISQLClient &trans, const
return ret;
}
int ObLSBackupInfoOperator::set_backup_version(common::ObISQLClient &trans, const uint64_t tenant_id, const uint64_t data_version)
{
int ret = OB_SUCCESS;
InfoItem item;
item.name_ = OB_STR_BACKUP_DATA_VERSION;
if (OB_FAIL(set_item_value(item.value_, data_version))) {
LOG_WARN("failed to set item value", K(ret), K(data_version));
} else if (OB_FAIL(insert_item_with_update(trans, tenant_id, item))) {
LOG_WARN("failed to insert item", K(ret), K(tenant_id), K(item));
}
return ret;
}
int ObLSBackupInfoOperator::get_backup_version(common::ObISQLClient &trans, const uint64_t tenant_id, uint64_t &data_version)
{
int ret = OB_SUCCESS;
InfoItem item;
item.name_ = OB_STR_BACKUP_DATA_VERSION;
char *endptr = NULL;
if (OB_FAIL(get_item(trans, tenant_id, item, false))) {
LOG_WARN("failed to get item", K(ret), K(tenant_id));
} else if (OB_FAIL(ob_strtoull(item.value_.ptr(), endptr, data_version))) {
LOG_WARN("failed str to ull", K(ret), K(item));
} else if (OB_ISNULL(endptr) || OB_UNLIKELY('\0' != *endptr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(item));
}
return ret;
}
int ObLSBackupInfoOperator::set_cluster_version(common::ObISQLClient &trans, const uint64_t tenant_id, const uint64_t cluster_version)
{
int ret = OB_SUCCESS;
InfoItem item;
item.name_ = OB_STR_CLUSTER_VERSION;
if (OB_FAIL(set_item_value(item.value_, cluster_version))) {
LOG_WARN("failed to set item value", K(ret), K(cluster_version));
} else if (OB_FAIL(insert_item_with_update(trans, tenant_id, item))) {
LOG_WARN("failed to insert item", K(ret), K(tenant_id), K(item));
}
return ret;
}
int ObLSBackupInfoOperator::get_cluster_version(common::ObISQLClient &trans, const uint64_t tenant_id, uint64_t &cluster_version)
{
int ret = OB_SUCCESS;
InfoItem item;
item.name_ = OB_STR_CLUSTER_VERSION;
char *endptr = NULL;
if (OB_FAIL(get_item(trans, tenant_id, item, false))) {
LOG_WARN("failed to get item", K(ret), K(tenant_id));
} else if (OB_FAIL(ob_strtoull(item.value_.ptr(), endptr, cluster_version))) {
LOG_WARN("failed str to ull", K(ret), K(item));
} else if (OB_ISNULL(endptr) || OB_UNLIKELY('\0' != *endptr)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(item));
}
return ret;
}
int ObLSBackupInfoOperator::get_item(
common::ObISQLClient &proxy,
const uint64_t tenant_id,
@ -2679,6 +2747,23 @@ int ObLSBackupInfoOperator::set_item_value(Value &dst_value, int64_t src_value)
return ret;
}
int ObLSBackupInfoOperator::set_item_value(Value &dst_value, uint64_t src_value)
{
int ret = OB_SUCCESS;
if (0 == src_value) {
if (OB_FAIL(set_item_value(dst_value, ""))) {
LOG_WARN("failed to set value", K(ret), K(src_value));
}
} else {
int strlen = sprintf(dst_value.ptr(), "%lu", src_value);
if (strlen <= 0 || strlen > common::OB_INNER_TABLE_DEFAULT_VALUE_LENTH) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to set value", K(ret), K(src_value), K(strlen));
}
}
return ret;
}
int ObLSBackupInfoOperator::set_item_value(Value &dst_value, const char *src_buf)
{
int ret = OB_SUCCESS;

5
src/share/backup/ob_backup_data_table_operator.h
View File

@ -199,10 +199,15 @@ public:
static int get_next_task_id(common::ObISQLClient &trans, const uint64_t tenant_id, int64_t &task_id);
static int get_next_backup_set_id(common::ObISQLClient &trans, const uint64_t &tenant_id, int64_t &backup_set_id);
static int get_next_dest_id(common::ObISQLClient &trans, const uint64_t &tenant_id, int64_t &dest_id);
static int set_backup_version(common::ObISQLClient &trans, const uint64_t tenant_id, const uint64_t data_version);
static int get_backup_version(common::ObISQLClient &trans, const uint64_t tenant_id, uint64_t &data_version);
static int set_cluster_version(common::ObISQLClient &trans, const uint64_t tenant_id, const uint64_t cluster_version);
static int get_cluster_version(common::ObISQLClient &trans, const uint64_t tenant_id, uint64_t &cluster_version);
private:
static int get_item(common::ObISQLClient &proxy, const uint64_t tenant_id, InfoItem &item, const bool need_lock);
static int insert_item_with_update(common::ObISQLClient &proxy, const uint64_t tenant_id, InfoItem &item);
static int set_item_value(Value &dst_value, int64_t src_value);
static int set_item_value(Value &dst_value, uint64_t src_value);
static int set_item_value(Value &dst_value, const char *src_buf);
};

55
src/share/backup/ob_backup_struct.cpp
View File

@ -23,6 +23,7 @@
#include "share/backup/ob_backup_config.h"
#include "share/backup/ob_backup_lease_info_mgr.h"
#include "storage/tx/ob_i_ts_source.h"
#include "storage/tx/ob_ts_mgr.h"
using namespace oceanbase;
@ -2030,6 +2031,22 @@ int ObBaseBackupInfoStruct::check_backup_info_match(
return ret;
}
int ObBackupUtils::check_tenant_data_version_match(const uint64_t tenant_id, const uint64_t data_version)
{
int ret = OB_SUCCESS;
uint64_t cur_data_version = 0;
if (!is_valid_tenant_id(tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id));
} else if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, cur_data_version))) {
LOG_WARN("failed to get min data version", K(ret), K(tenant_id));
} else if (cur_data_version != data_version) {
ret = OB_VERSION_NOT_MATCH;
LOG_WARN("tenant data version is not match", K(ret), K(tenant_id), K(cur_data_version), K(data_version));
}
return ret;
}
int ObBackupUtils::get_backup_info_default_timeout_ctx(ObTimeoutCtx &ctx)
{
int ret = OB_SUCCESS;
@ -2164,6 +2181,37 @@ int ObBackupUtils::convert_timestamp_to_date(
return ret;
}
int ObBackupUtils::get_backup_scn(const uint64_t &tenant_id, share::SCN &scn)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tenant id is invalid", KR(ret), K(tenant_id));
} else {
ret = OB_EAGAIN;
const transaction::MonotonicTs stc = transaction::MonotonicTs::current_time();
transaction::MonotonicTs unused_ts(0);
const int64_t start_time = ObTimeUtility::fast_current_time();
const int64_t TIMEOUT = 10 * 1000 * 1000; //10s
while (OB_EAGAIN == ret) {
if (ObTimeUtility::fast_current_time() - start_time > TIMEOUT) {
ret = OB_TIMEOUT;
LOG_WARN("stmt is timeout", KR(ret), K(start_time), K(TIMEOUT));
} else if (OB_FAIL(OB_TS_MGR.get_gts(tenant_id, stc, NULL,
scn, unused_ts))) {
if (OB_EAGAIN != ret) {
LOG_WARN("failed to get gts", KR(ret), K(tenant_id));
} else {
// waiting 10ms
ob_usleep(10L * 1000L);
}
}
}
}
LOG_INFO("get tenant gts", KR(ret), K(tenant_id), K(scn));
return ret;
}
int ObBackupUtils::convert_timestamp_to_timestr(const int64_t ts, char *buf, int64_t len)
{
int ret = OB_SUCCESS;
@ -3465,7 +3513,7 @@ int ObBackupLSTaskAttr::assign(const ObBackupLSTaskAttr &other)
OB_SERIALIZE_MEMBER(ObBackupSetFileDesc, backup_set_id_, incarnation_, tenant_id_, dest_id_, backup_type_,
plus_archivelog_, date_, prev_full_backup_set_id_, prev_inc_backup_set_id_, stats_, start_time_, end_time_, status_,
result_, encryption_mode_, passwd_, file_status_, backup_path_, start_replay_scn_, min_restore_scn_,
tenant_compatible_, backup_compatible_, data_turn_id_, meta_turn_id_);
tenant_compatible_, backup_compatible_, data_turn_id_, meta_turn_id_, cluster_version_);
ObBackupSetFileDesc::ObBackupSetFileDesc()
: backup_set_id_(0),
@ -3491,7 +3539,8 @@ ObBackupSetFileDesc::ObBackupSetFileDesc()
tenant_compatible_(0),
backup_compatible_(Compatible::MAX_COMPATIBLE_VERSION),
data_turn_id_(0),
meta_turn_id_(0)
meta_turn_id_(0),
cluster_version_(0)
{
}
@ -3521,6 +3570,7 @@ void ObBackupSetFileDesc::reset()
backup_compatible_ = Compatible::MAX_COMPATIBLE_VERSION;
data_turn_id_ = 0;
meta_turn_id_ = 0;
cluster_version_ = 0;
}
@ -3656,6 +3706,7 @@ int ObBackupSetFileDesc::assign(const ObBackupSetFileDesc &other)
backup_compatible_ = other.backup_compatible_;
data_turn_id_ = other.data_turn_id_;
meta_turn_id_ = other.meta_turn_id_;
cluster_version_ = other.cluster_version_;
}
return ret;
}

10
src/share/backup/ob_backup_struct.h
View File

@ -383,6 +383,8 @@ const char *const OB_STR_BACKUP_SET_LIST = "backup_set_list";
const char *const OB_STR_BACKUP_PIECE_LIST = "backup_piece_list";
const char *const OB_STR_LOG_PATH_LIST = "log_path_list";
const char *const OB_STR_LS_META_INFOS = "ls_meta_infos";
const char *const OB_STR_BACKUP_DATA_VERSION = "backup_data_version";
const char *const OB_STR_CLUSTER_VERSION = "cluster_version";
const char *const OB_BACKUP_SUFFIX=".obbak";
const char *const OB_ARCHIVE_SUFFIX=".obarc";
@ -996,6 +998,8 @@ public:
static bool can_backup_pieces_be_deleted(const ObBackupPieceStatus::STATUS &status);
static int check_passwd(const char *passwd_array, const char *passwd);
static int check_is_tmp_file(const common::ObString &file_name, bool &is_tmp_file);
static int get_backup_scn(const uint64_t &tenant_id, share::SCN &scn);
static int check_tenant_data_version_match(const uint64_t tenant_id, const uint64_t data_version);
private:
static const int64_t RETRY_INTERVAL = 10 * 1000 * 1000;
static const int64_t MAX_RETRY_TIMES = 3;
@ -1417,6 +1421,8 @@ public:
enum Compatible : int64_t
{
COMPATIBLE_VERSION_1 = 1, // 4.0
COMPATIBLE_VERSION_2, // 4.1
MAX_COMPATIBLE_VERSION,
};
@ -1442,7 +1448,8 @@ public:
TO_STRING_KV(K_(backup_set_id), K_(incarnation), K_(tenant_id), K_(dest_id), K_(backup_type), K_(plus_archivelog),
K_(date), K_(prev_full_backup_set_id), K_(prev_inc_backup_set_id), K_(stats), K_(start_time), K_(end_time),
K_(status), K_(result), K_(encryption_mode), K_(passwd), K_(file_status), K_(backup_path), K_(start_replay_scn),
K_(min_restore_scn), K_(tenant_compatible), K_(backup_compatible), K_(data_turn_id), K_(meta_turn_id));
K_(min_restore_scn), K_(tenant_compatible), K_(backup_compatible), K_(data_turn_id), K_(meta_turn_id),
K_(cluster_version));
int64_t backup_set_id_;
int64_t incarnation_;
@ -1468,6 +1475,7 @@ public:
Compatible backup_compatible_;
int64_t data_turn_id_;
int64_t meta_turn_id_;
uint64_t cluster_version_;
};
struct ObBackupSkippedType;

19
src/share/inner_table/ob_inner_table_schema.12251_12300.cpp
View File

@ -11633,6 +11633,25 @@ int ObInnerTableSchema::all_virtual_backup_set_files_schema(ObTableSchema &table
path_default,
path_default); //default_value
}
if (OB_SUCC(ret)) {
ObObj cluster_version_default;
cluster_version_default.set_varchar(ObString::make_string(""));
ADD_COLUMN_SCHEMA_T("cluster_version", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_INVALID, //column_collation_type
OB_INNER_TABLE_DEFAULT_VALUE_LENTH, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false, //is_autoincrement
cluster_version_default,
cluster_version_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);

15
src/share/inner_table/ob_inner_table_schema.15201_15250.cpp
View File

@ -11712,6 +11712,21 @@ int ObInnerTableSchema::all_virtual_backup_set_files_ora_schema(ObTableSchema &t
true, //is_nullable
false); //is_autoincrement
}
if (OB_SUCC(ret)) {
ADD_COLUMN_SCHEMA("CLUSTER_VERSION", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_UTF8MB4_BIN, //column_collation_type
OB_INNER_TABLE_DEFAULT_VALUE_LENTH, //column_length
2, //column_precision
-1, //column_scale
true, //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);

2
src/share/inner_table/ob_inner_table_schema.21101_21150.cpp
View File

@ -660,7 +660,7 @@ int ObInnerTableSchema::cdb_ob_backup_set_files_schema(ObTableSchema &table_sche
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, BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_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, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, 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, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_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, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, 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, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH, CLUSTER_VERSION FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}

2
src/share/inner_table/ob_inner_table_schema.21251_21300.cpp
View File

@ -760,7 +760,7 @@ int ObInnerTableSchema::dba_ob_backup_set_files_schema(ObTableSchema &table_sche
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 BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_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, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, 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, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_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, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN NULL ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, 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, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH, CLUSTER_VERSION FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}

2
src/share/inner_table/ob_inner_table_schema.25151_25200.cpp
View File

@ -1560,7 +1560,7 @@ int ObInnerTableSchema::dba_ob_backup_set_files_ora_schema(ObTableSchema &table_
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 BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN NULL ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, SCN_TO_TIMESTAMP(START_REPLAY_SCN) AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) AS MIN_RESTORE_SCN_DISPLAY, 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", ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM SYS.ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN NULL ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, SCN_TO_TIMESTAMP(START_REPLAY_SCN) AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) AS MIN_RESTORE_SCN_DISPLAY, 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", ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH, CLUSTER_VERSION FROM SYS.ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
LOG_ERROR("fail to set view_definition", K(ret));
}
}

19
src/share/inner_table/ob_inner_table_schema.301_350.cpp
View File

@ -1649,6 +1649,25 @@ int ObInnerTableSchema::all_backup_set_files_schema(ObTableSchema &table_schema)
path_default,
path_default); //default_value
}
if (OB_SUCC(ret)) {
ObObj cluster_version_default;
cluster_version_default.set_varchar(ObString::make_string(""));
ADD_COLUMN_SCHEMA_T("cluster_version", //column_name
++column_id, //column_id
0, //rowkey_id
0, //index_id
0, //part_key_pos
ObVarcharType, //column_type
CS_TYPE_INVALID, //column_collation_type
OB_INNER_TABLE_DEFAULT_VALUE_LENTH, //column_length
-1, //column_precision
-1, //column_scale
false, //is_nullable
false, //is_autoincrement
cluster_version_default,
cluster_version_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);

10
src/share/inner_table/ob_inner_table_schema_def.py
View File

@ -2846,6 +2846,7 @@ all_backup_set_files_def = dict(
('tenant_compatible', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH'),
('backup_compatible', 'int'),
('path', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'true', ''),
('cluster_version', 'varchar:OB_INNER_TABLE_DEFAULT_VALUE_LENTH', 'false', ''),
],
)
def_table_schema(**all_backup_set_files_def)
@ -14970,7 +14971,8 @@ def_table_schema(
PASSWD,
TENANT_COMPATIBLE,
BACKUP_COMPATIBLE,
PATH
PATH,
CLUSTER_VERSION
FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES
""".replace("\n", " ")
)
@ -21689,7 +21691,8 @@ def_table_schema(
PASSWD,
TENANT_COMPATIBLE,
BACKUP_COMPATIBLE,
PATH
PATH,
CLUSTER_VERSION
FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES
WHERE TENANT_ID = EFFECTIVE_TENANT_ID()
""".replace("\n", " ")
@ -41084,7 +41087,8 @@ def_table_schema(
PASSWD,
TENANT_COMPATIBLE,
BACKUP_COMPATIBLE,
PATH
PATH,
CLUSTER_VERSION
FROM SYS.ALL_VIRTUAL_BACKUP_SET_FILES
WHERE TENANT_ID = EFFECTIVE_TENANT_ID()
""".replace("\n", " ")

9
src/share/restore/ob_physical_restore_info.cpp
View File

@ -242,8 +242,9 @@ DEF_TO_STRING(ObPhysicalRestoreJob)
K_(comment),
K_(restore_start_ts),
K_(restore_scn),
K_(post_cluster_version),
K_(post_data_version),
K_(source_cluster_version),
K_(source_data_version),
K_(restore_option),
K_(backup_dest),
K_(description),
@ -278,8 +279,9 @@ int ObPhysicalRestoreJob::assign(const ObPhysicalRestoreJob &other)
status_ = other.status_;
restore_start_ts_ = other.restore_start_ts_;
restore_scn_ = other.restore_scn_;
post_cluster_version_ = other.post_cluster_version_;
post_data_version_ = other.post_data_version_;
source_cluster_version_ = other.source_cluster_version_;
source_data_version_ = other.source_data_version_;
compat_mode_ = other.compat_mode_;
compatible_ = other.compatible_;
kms_encrypt_ = other.kms_encrypt_;
@ -332,8 +334,9 @@ void ObPhysicalRestoreJob::reset()
comment_.reset();
restore_start_ts_ = 0;
restore_scn_ = SCN::min_scn();
post_cluster_version_ = 0;
post_data_version_ = 0;
source_cluster_version_ = 0;
source_data_version_ = 0;
restore_option_.reset();
backup_dest_.reset();
description_.reset();

4
src/share/restore/ob_physical_restore_info.h
View File

@ -160,9 +160,9 @@ public:
Property_declare_int(int64_t, restore_start_ts)
Property_declare_int(share::SCN, restore_scn)
// TODO(chongrong.th): should use tenant's data version
Property_declare_int(uint64_t, post_cluster_version)
Property_declare_int(uint64_t, post_data_version)
Property_declare_int(uint64_t, source_cluster_version)
Property_declare_int(uint64_t, source_data_version)
//from cmd
Property_declare_ObString(restore_option)
Property_declare_ObString(backup_dest)

42
src/share/restore/ob_physical_restore_table_operator.cpp
View File

@ -218,17 +218,17 @@ int ObPhysicalRestoreTableOperator::fill_dml_splicer(
if (OB_SUCC(ret)) {
ADD_COLUMN_WITH_VALUE(job_info, restore_type, (int64_t)(job_info.get_restore_type()));
}
// post_cluster_version
// post_data_version
if (OB_SUCC(ret)) {
uint64_t post_cluster_version = job_info.get_post_cluster_version();
uint64_t post_data_version = job_info.get_post_data_version();
int64_t len = ObClusterVersion::print_version_str(
version, common::OB_CLUSTER_VERSION_LENGTH, post_cluster_version);
version, common::OB_CLUSTER_VERSION_LENGTH, post_data_version);
if (len < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid post_cluster_version", K(ret),
K(post_cluster_version));
LOG_WARN("invalid post_data_version", K(ret),
K(post_data_version));
} else {
ADD_COLUMN_WITH_VALUE(job_info, post_cluster_version, ObString(len, version));
ADD_COLUMN_WITH_VALUE(job_info, post_data_version, ObString(len, version));
}
}
// status
@ -273,6 +273,18 @@ int ObPhysicalRestoreTableOperator::fill_dml_splicer(
ADD_COLUMN_WITH_VALUE(job_info, source_cluster_version, ObString(len, version));
}
}
// source_data_version
if (OB_SUCC(ret)) {
uint64_t source_data_version = job_info.get_source_data_version();
int64_t len = ObClusterVersion::print_version_str(
version, common::OB_CLUSTER_VERSION_LENGTH, source_data_version);
if (len < 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid source_data_version", K(ret), K(source_data_version));
} else {
ADD_COLUMN_WITH_VALUE(job_info, source_data_version, ObString(len, version));
}
}
// while_list/b_while_list
if (OB_SUCC(ret)) {
ObArenaAllocator allocator("PhyWhiteList");
@ -532,7 +544,7 @@ int ObPhysicalRestoreTableOperator::retrieve_restore_option(
}
if (OB_SUCC(ret)) {
if (name == "post_cluster_version") {
if (name == "post_data_version") {
ObString version_str;
uint64_t version = 0;
EXTRACT_VARCHAR_FIELD_MYSQL_SKIP_RET(result, "value", version_str);
@ -540,7 +552,7 @@ int ObPhysicalRestoreTableOperator::retrieve_restore_option(
} else if (OB_FAIL(ObClusterVersion::get_version(version_str, version))) {
LOG_WARN("fail to parser version", K(ret), K(version_str));
} else {
job.set_post_cluster_version(version);
job.set_post_data_version(version);
}
}
}
@ -558,6 +570,20 @@ int ObPhysicalRestoreTableOperator::retrieve_restore_option(
}
}
if (OB_SUCC(ret)) {
if (name == "source_data_version") {
ObString version_str;
uint64_t version = 0;
EXTRACT_VARCHAR_FIELD_MYSQL_SKIP_RET(result, "value", version_str);
if (OB_FAIL(ret)) {
} else if (OB_FAIL(ObClusterVersion::get_version(version_str, version))) {
LOG_WARN("fail to parser version", K(ret), K(version_str));
} else {
job.set_source_data_version(version);
}
}
}
if (OB_SUCC(ret)) {
if (name == OB_STR_BACKUP_SET_LIST) {
ObString str;