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

[Fix] use old execution id when select for update fail

Browse Source
This commit is contained in:
obdev 2022-12-19 07:07:59 +00:00 committed by ob-robot
parent 0575caf883
commit 194d99c19c
27 changed files with 90 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/rootserver/ddl_task/ob_ddl_retry_task.cpp
View File

@ -620,7 +620,7 @@ int ObDDLRetryTask::update_task_status_wait_child_task_finish(
int64_t affected_rows = 0;
ObSqlString sql_string;
int64_t curr_task_status = 0;
int64_t execution_id = 0; /*unused*/
int64_t execution_id = -1; /*unused*/
const int64_t new_task_status = ObDDLTaskStatus::WAIT_CHILD_TASK_FINISH;
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || task_id <= 0)) {
ret = OB_INVALID_ARGUMENT;

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

@ -902,7 +902,7 @@ int ObDDLScheduler::recover_task()
const ObDDLTaskRecord &cur_record = task_records.at(i);
int64_t tenant_schema_version = 0;
int64_t table_task_status = 0;
int64_t execution_id = 0;
int64_t execution_id = -1;
ObMySQLTransaction trans;
if (OB_FAIL(schema_service.get_tenant_schema_version(cur_record.tenant_id_, tenant_schema_version))) {
LOG_WARN("failed to get tenant schema version", K(ret), K(cur_record));
@ -1317,9 +1317,8 @@ int ObDDLScheduler::on_update_execution_id(
K(ret), K(task_id), KPC(ddl_task));
} else if (OB_FAIL(ddl_task->push_execution_id())) {
LOG_WARN("fail to push execution id", K(ret), KPC(ddl_task));
} else {
ret_execution_id = ddl_task->get_execution_id();
}
ret_execution_id = ddl_task->get_execution_id(); // ignore ret, if fail, take old execution id
}
return ret;
}
@ -1335,7 +1334,7 @@ int ObDDLScheduler::on_sstable_complement_job_reply(
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (OB_UNLIKELY(!(task_key.is_valid() && snapshot_version > 0 && execution_id > 0))) {
} else if (OB_UNLIKELY(!(task_key.is_valid() && snapshot_version > 0 && execution_id >= 0))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(task_key), K(snapshot_version), K(execution_id), K(ret_code));
} else {

4
src/rootserver/ddl_task/ob_ddl_single_replica_executor.h
View File

@ -36,14 +36,14 @@ public:
snapshot_version_(0),
task_id_(0),
parallelism_(0),
execution_id_(0)
execution_id_(-1)
{}
~ObDDLSingleReplicaExecutorParam() = default;
bool is_valid() const {
return common::OB_INVALID_TENANT_ID != tenant_id_ && share::DDL_INVALID != type_
&& source_tablet_ids_.count() > 0 && dest_tablet_ids_.count() > 0
&& common::OB_INVALID_ID != source_table_id_ && common::OB_INVALID_ID != dest_table_id_
&& schema_version_ > 0 && snapshot_version_ > 0 && task_id_ > 0 && execution_id_ > 0;
&& schema_version_ > 0 && snapshot_version_ > 0 && task_id_ > 0 && execution_id_ >= 0;
}
TO_STRING_KV(K_(tenant_id), K_(type), K_(source_tablet_ids), K_(dest_tablet_ids),
K_(source_table_id), K_(dest_table_id), K_(schema_version),

25
src/rootserver/ddl_task/ob_ddl_task.cpp
View File

@ -320,7 +320,7 @@ int ObDDLTask::switch_status(ObDDLTaskStatus new_status, const int ret_code)
LOG_WARN("start transaction failed", K(ret));
} else {
int64_t table_task_status = 0;
int64_t execution_id = 0;
int64_t execution_id = -1;
if (OB_FAIL(ObDDLTaskRecordOperator::select_for_update(trans, tenant_id_, task_id_, table_task_status, execution_id))) {
LOG_WARN("select for update failed", K(ret), K(task_id_));
} else if (old_status != task_status_) {
@ -607,8 +607,6 @@ int ObDDLTask::push_execution_id()
LOG_WARN("select for update failed", K(ret), K(task_id));
} else if (OB_FAIL(ObDDLTaskRecordOperator::update_execution_id(trans, tenant_id_, task_id_, table_execution_id + 1))) {
LOG_WARN("update task status failed", K(ret));
} else {
execution_id_ = table_execution_id + 1;
}
bool commit = (OB_SUCCESS == ret);
int tmp_ret = trans.end(commit);
@ -616,6 +614,11 @@ int ObDDLTask::push_execution_id()
LOG_WARN("fail to end trans", K(tmp_ret));
ret = (OB_SUCCESS == ret) ? tmp_ret : ret;
}
if (OB_SUCC(ret)) {
execution_id_ = table_execution_id + 1;
} else {
execution_id_ = execution_id_ >= 0 ? execution_id_ : 0; // use old execution or inner table default value(0)
}
}
return ret;
}
@ -1178,7 +1181,7 @@ int ObDDLWaitColumnChecksumCtx::init(
const uint64_t target_table_id,
const int64_t schema_version,
const int64_t snapshot_version,
const uint64_t execution_id,
const int64_t execution_id,
const int64_t timeout_us)
{
int ret = OB_SUCCESS;
@ -1192,7 +1195,7 @@ int ObDDLWaitColumnChecksumCtx::init(
|| OB_INVALID_ID == target_table_id
|| schema_version <= 0
|| snapshot_version <= 0
|| OB_INVALID_ID == execution_id
|| execution_id < 0
|| timeout_us <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(task_id), K(tenant_id), K(source_table_id), K(target_table_id),
@ -1248,7 +1251,7 @@ void ObDDLWaitColumnChecksumCtx::reset()
target_table_id_ = OB_INVALID_ID;
schema_version_ = 0;
snapshot_version_ = 0;
execution_id_ = OB_INVALID_ID;
execution_id_ = -1;
timeout_us_ = 0;
last_drive_ts_ = 0;
stat_array_.reset();
@ -1507,7 +1510,7 @@ bool ObDDLTaskRecord::is_valid() const
&& task_version_ > 0
&& OB_INVALID_ID != object_id_
&& schema_version_ > 0
&& execution_id_ >= 0;
&& execution_id_ >= -1;
return is_valid;
}
@ -1526,7 +1529,7 @@ void ObDDLTaskRecord::reset()
message_.reset();
task_version_ = 0;
ret_code_ = OB_SUCCESS;
execution_id_ = 0;
execution_id_ = -1; // -1 is invalid
}
@ -1612,7 +1615,7 @@ int ObDDLTaskRecordOperator::update_execution_id(
int ret = OB_SUCCESS;
ObSqlString sql_string;
int64_t affected_rows = 0;
if (OB_ISNULL(sql_client.get_pool()) || OB_UNLIKELY(task_id <= 0 || tenant_id <= 0 || execution_id <= 0)) {
if (OB_ISNULL(sql_client.get_pool()) || OB_UNLIKELY(task_id <= 0 || tenant_id <= 0 || execution_id < 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arg", K(ret), K(tenant_id), K(task_id));
} else if (OB_FAIL(sql_string.assign_fmt(" UPDATE %s SET execution_id=%lu WHERE task_id=%lu ",
@ -1909,7 +1912,7 @@ int ObDDLTaskRecordOperator::insert_record(
LOG_WARN("append hex escaped string failed", K(ret));
} else if (OB_FAIL(sql_string.assign_fmt(
" INSERT INTO %s (task_id, parent_task_id, tenant_id, object_id, schema_version, target_object_id, ddl_type, trace_id, status, task_version, execution_id, ret_code, ddl_stmt_str, message) "
" VALUES (%lu, %lu, %lu, %lu, %lu, %lu, %d, '%s', %ld, %lu, %lu, %lu, '%.*s', \"%.*s\") ",
" VALUES (%lu, %lu, %lu, %lu, %lu, %lu, %d, '%s', %ld, %lu, %ld, %lu, '%.*s', \"%.*s\") ",
OB_ALL_DDL_TASK_STATUS_TNAME, record.task_id_, record.parent_task_id_,
ObSchemaUtils::get_extract_tenant_id(record.tenant_id_, record.tenant_id_), record.object_id_, record.schema_version_,
get_record_id(record.ddl_type_, record.target_object_id_), record.ddl_type_, trace_id_str, record.task_status_, record.task_version_, record.execution_id_, record.ret_code_,
@ -2012,7 +2015,7 @@ int ObDDLTaskRecordOperator::select_for_update(
int ret = OB_SUCCESS;
ObSqlString sql_string;
task_status = 0;
execution_id = 0;
execution_id = 0; // default in OB_ALL_DDL_TASK_STATUS_TNAME is 0
if (OB_UNLIKELY(task_id <= 0 || tenant_id <= 0)) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret), K(tenant_id), K(task_id));

12
src/rootserver/ddl_task/ob_ddl_task.h
View File

@ -274,7 +274,7 @@ public:
target_object_id_(0), task_status_(share::ObDDLTaskStatus::PREPARE), snapshot_version_(0), ret_code_(OB_SUCCESS), task_id_(0),
parent_task_id_(0), parent_task_key_(), task_version_(0), parallelism_(0),
allocator_(lib::ObLabel("DdlTask")), compat_mode_(lib::Worker::CompatMode::INVALID), err_code_occurence_cnt_(0),
delay_schedule_time_(0), next_schedule_ts_(0), execution_id_(0), sql_exec_addr_()
delay_schedule_time_(0), next_schedule_ts_(0), execution_id_(-1), sql_exec_addr_()
{}
virtual ~ObDDLTask() {}
virtual int process() = 0;
@ -387,18 +387,18 @@ struct PartitionColChecksumStat
: tablet_id_(),
col_checksum_stat_(CCS_INVALID),
snapshot_(-1),
execution_id_(common::OB_INVALID_ID),
execution_id_(-1),
ret_code_(OB_SUCCESS)
{}
void reset() {
tablet_id_.reset();
col_checksum_stat_ = CCS_INVALID;
snapshot_ = -1;
execution_id_ = common::OB_INVALID_ID;
execution_id_ = -1;
ret_code_ = common::OB_SUCCESS;
table_id_ = common::OB_INVALID_ID;
}
bool is_valid() const { return tablet_id_.is_valid() && common::OB_INVALID_ID != execution_id_ && common::OB_INVALID_ID != table_id_; }
bool is_valid() const { return tablet_id_.is_valid() && execution_id_ >= 0 && common::OB_INVALID_ID != table_id_; }
TO_STRING_KV(K_(tablet_id),
K_(col_checksum_stat),
K_(snapshot),
@ -407,7 +407,7 @@ struct PartitionColChecksumStat
ObTabletID tablet_id_; // may be data table, local index or global index
ColChecksumStat col_checksum_stat_;
int64_t snapshot_;
uint64_t execution_id_;
int64_t execution_id_;
int ret_code_;
int64_t table_id_;
};
@ -424,7 +424,7 @@ public:
const uint64_t target_table_id,
const int64_t schema_version,
const int64_t snapshot_version,
const uint64_t execution_id,
const int64_t execution_id,
const int64_t timeout_us);
void reset();
bool is_inited() const { return is_inited_; }

12
src/share/ob_build_index_struct.h
View File

@ -23,19 +23,19 @@ namespace share
struct ObBuildIndexAppendLocalDataParam
{
ObBuildIndexAppendLocalDataParam()
: execution_id_(common::OB_INVALID_ID), task_id_(common::OB_INVALID_ID),
: execution_id_(-1), task_id_(common::OB_INVALID_ID),
index_id_(common::OB_INVALID_ID), schema_version_(common::OB_INVALID_VERSION),
task_cnt_(0)
{}
virtual ~ObBuildIndexAppendLocalDataParam() {}
bool is_valid() const
{
return common::OB_INVALID_ID != execution_id_ && common::OB_INVALID_ID != task_id_
return 0 <= execution_id_ && common::OB_INVALID_ID != task_id_
&& common::OB_INVALID_ID != index_id_ && common::OB_INVALID_VERSION != schema_version_
&& 0 != task_cnt_ && task_id_ < task_cnt_;
}
TO_STRING_KV(K_(execution_id), K_(task_id), K_(index_id), K_(schema_version), K_(task_cnt));
uint64_t execution_id_;
int64_t execution_id_;
uint64_t task_id_;
uint64_t index_id_;
int64_t schema_version_;
@ -45,18 +45,18 @@ struct ObBuildIndexAppendLocalDataParam
struct ObBuildIndexAppendSSTableParam
{
ObBuildIndexAppendSSTableParam()
: index_id_(common::OB_INVALID_ID), schema_version_(common::OB_INVALID_VERSION), execution_id_(common::OB_INVALID_ID)
: index_id_(common::OB_INVALID_ID), schema_version_(common::OB_INVALID_VERSION), execution_id_(-1)
{}
virtual ~ObBuildIndexAppendSSTableParam() {}
bool is_valid() const
{
return common::OB_INVALID_ID != index_id_ && common::OB_INVALID_VERSION != schema_version_
&& common::OB_INVALID_ID != execution_id_;
&& 0 <= execution_id_;
}
TO_STRING_KV(K_(index_id), K_(schema_version), K_(execution_id));
uint64_t index_id_;
int64_t schema_version_;
uint64_t execution_id_;
int64_t execution_id_;
};
} // end namespace share

12
src/share/ob_ddl_checksum.cpp
View File

@ -207,7 +207,7 @@ int ObDDLChecksumOperator::get_column_checksum(const ObSqlString &sql, const uin
int ObDDLChecksumOperator::get_table_column_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t table_id,
const int64_t ddl_task_id,
common::hash::ObHashMap<int64_t, int64_t> &column_checksum_map,
@ -216,7 +216,7 @@ int ObDDLChecksumOperator::get_table_column_checksum(
int ret = OB_SUCCESS;
ObSqlString sql;
const uint64_t exec_tenant_id = ObSchemaUtils::get_exec_tenant_id(tenant_id);
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == execution_id || OB_INVALID_ID == table_id
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || execution_id < 0 || OB_INVALID_ID == table_id
|| OB_INVALID_ID == ddl_task_id || !column_checksum_map.created())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(execution_id), K(table_id), K(ddl_task_id),
@ -236,7 +236,7 @@ int ObDDLChecksumOperator::get_table_column_checksum(
int ObDDLChecksumOperator::check_column_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t data_table_id,
const uint64_t index_table_id,
const int64_t ddl_task_id,
@ -247,7 +247,7 @@ int ObDDLChecksumOperator::check_column_checksum(
hash::ObHashMap<int64_t, int64_t> data_table_column_checksums;
hash::ObHashMap<int64_t, int64_t> index_table_column_checksums;
is_equal = true;
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == execution_id || OB_INVALID_ID == data_table_id
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || execution_id < 0 || OB_INVALID_ID == data_table_id
|| OB_INVALID_ID == index_table_id || OB_INVALID_ID == ddl_task_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(execution_id), K(data_table_id), K(index_table_id), K(ddl_task_id));
@ -286,7 +286,7 @@ int ObDDLChecksumOperator::check_column_checksum(
int ObDDLChecksumOperator::delete_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t source_table_id,
const uint64_t dest_table_id,
const int64_t ddl_task_id,
@ -296,7 +296,7 @@ int ObDDLChecksumOperator::delete_checksum(
ObSqlString sql;
int64_t affected_rows = 0;
const uint64_t exec_tenant_id = ObSchemaUtils::get_exec_tenant_id(tenant_id);
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == execution_id || OB_INVALID_ID == ddl_task_id
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || execution_id < 0 || OB_INVALID_ID == ddl_task_id
|| OB_INVALID_ID == source_table_id || OB_INVALID_ID == dest_table_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(tenant_id), K(execution_id), K(source_table_id), K(dest_table_id));

12
src/share/ob_ddl_checksum.h
View File

@ -26,14 +26,14 @@ namespace share
struct ObDDLChecksumItem
{
ObDDLChecksumItem()
: execution_id_(common::OB_INVALID_ID), tenant_id_(common::OB_INVALID_ID),
: execution_id_(-1), tenant_id_(common::OB_INVALID_ID),
table_id_(common::OB_INVALID_ID), ddl_task_id_(0),
column_id_(common::OB_INVALID_ID), task_id_(common::OB_INVALID_ID), checksum_(0)
{}
~ObDDLChecksumItem() {};
bool is_valid() const
{
return common::OB_INVALID_ID != execution_id_
return 0 <= execution_id_
&& common::OB_INVALID_ID != tenant_id_
&& common::OB_INVALID_ID != table_id_
&& 0 < ddl_task_id_
@ -41,7 +41,7 @@ struct ObDDLChecksumItem
}
TO_STRING_KV(K_(execution_id), K_(tenant_id), K_(table_id),
K_(ddl_task_id), K_(column_id), K_(task_id), K_(checksum));
uint64_t execution_id_;
int64_t execution_id_;
uint64_t tenant_id_;
uint64_t table_id_;
int64_t ddl_task_id_;
@ -66,13 +66,13 @@ public:
common::ObMySQLProxy &sql_proxy);
static int get_table_column_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t table_id,
const int64_t ddl_task_id,
common::hash::ObHashMap<int64_t, int64_t> &column_checksums, common::ObMySQLProxy &sql_proxy);
static int check_column_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t data_table_id,
const uint64_t index_table_id,
const int64_t ddl_task_id,
@ -80,7 +80,7 @@ public:
common::ObMySQLProxy &sql_proxy);
static int delete_checksum(
const uint64_t tenant_id,
const uint64_t execution_id,
const int64_t execution_id,
const uint64_t source_table_id,
const uint64_t dest_table_id,
const int64_t ddl_task_id,

2
src/share/ob_ddl_common.cpp
View File

@ -442,7 +442,7 @@ int ObDDLUtil::generate_build_replica_sql(
const ObTableSchema *dest_table_schema = nullptr;
bool oracle_mode = false;
if (OB_UNLIKELY(OB_INVALID_ID == tenant_id || OB_INVALID_ID == data_table_id || OB_INVALID_ID == dest_table_id
|| schema_version <= 0 || snapshot_version <= 0 || execution_id <= 0 || task_id <= 0)) {
|| schema_version <= 0 || snapshot_version <= 0 || execution_id < 0 || task_id <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K(tenant_id), K(data_table_id), K(dest_table_id), K(schema_version),
K(snapshot_version), K(execution_id), K(task_id));

8
src/share/ob_rpc_struct.cpp
View File

@ -2681,7 +2681,7 @@ OB_SERIALIZE_MEMBER(
bool ObCalcColumnChecksumRequestArg::is_valid() const
{
bool bret = OB_INVALID_ID != tenant_id_ && OB_INVALID_ID != target_table_id_
&& OB_INVALID_VERSION != schema_version_ && OB_INVALID_ID != execution_id_
&& OB_INVALID_VERSION != schema_version_ && execution_id_ >= 0
&& OB_INVALID_VERSION != snapshot_version_ && OB_INVALID_ID != source_table_id_ && task_id_ > 0;
for (int64_t i = 0; bret && i < calc_items_.count(); ++i) {
bret = calc_items_.at(i).is_valid();
@ -2694,9 +2694,9 @@ void ObCalcColumnChecksumRequestArg::reset()
tenant_id_ = OB_INVALID_ID;
target_table_id_ = OB_INVALID_ID;
schema_version_ = OB_INVALID_VERSION;
execution_id_ = OB_INVALID_ID;
snapshot_version_ = OB_INVALID_VERSION;
source_table_id_ = OB_INVALID_ID;
execution_id_ = -1;
task_id_ = 0;
calc_items_.reset();
}
@ -6708,7 +6708,7 @@ OB_SERIALIZE_MEMBER(ObRpcRemoteWriteDDLRedoLogArg, tenant_id_, ls_id_, redo_info
ObRpcRemoteWriteDDLPrepareLogArg::ObRpcRemoteWriteDDLPrepareLogArg()
: tenant_id_(OB_INVALID_ID), ls_id_(), table_key_(), start_scn_(SCN::min_scn()),
table_id_(0), execution_id_(0), ddl_task_id_(0)
table_id_(0), execution_id_(-1), ddl_task_id_(0)
{}
int ObRpcRemoteWriteDDLPrepareLogArg::init(const uint64_t tenant_id,
@ -6721,7 +6721,7 @@ int ObRpcRemoteWriteDDLPrepareLogArg::init(const uint64_t tenant_id,
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(tenant_id == OB_INVALID_ID || !ls_id.is_valid() || !table_key.is_valid() || !start_scn.is_valid_and_not_min()
|| table_id <= 0 || execution_id <= 0 || ddl_task_id <= 0)) {
|| table_id <= 0 || execution_id < 0 || ddl_task_id <= 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("tablet id is not valid", K(ret), K(tenant_id), K(ls_id), K(table_key), K(start_scn),
K(table_id), K(execution_id), K(ddl_task_id));

10
src/share/ob_rpc_struct.h
View File

@ -2894,7 +2894,7 @@ public:
uint64_t tenant_id_;
uint64_t target_table_id_;
int64_t schema_version_;
uint64_t execution_id_;
int64_t execution_id_;
int64_t snapshot_version_;
int64_t source_table_id_;
int64_t task_id_;
@ -7187,7 +7187,7 @@ public:
ObDDLBuildSingleReplicaRequestArg() : tenant_id_(OB_INVALID_ID), ls_id_(), source_tablet_id_(), dest_tablet_id_(),
source_table_id_(OB_INVALID_ID), dest_schema_id_(OB_INVALID_ID),
schema_version_(0), snapshot_version_(0), ddl_type_(0), task_id_(0),
parallelism_(0), execution_id_(0), tablet_task_id_(0) {}
parallelism_(0), execution_id_(-1), tablet_task_id_(0) {}
bool is_valid() const {
return OB_INVALID_ID != tenant_id_ && ls_id_.is_valid() && source_tablet_id_.is_valid() && dest_tablet_id_.is_valid()
&& OB_INVALID_ID != source_table_id_ && OB_INVALID_ID != dest_schema_id_ && schema_version_ > 0 && snapshot_version_ > 0
@ -7233,12 +7233,12 @@ struct ObDDLBuildSingleReplicaResponseArg final
public:
ObDDLBuildSingleReplicaResponseArg()
: tenant_id_(OB_INVALID_ID), ls_id_(), tablet_id_(), source_table_id_(), dest_schema_id_(OB_INVALID_ID),
ret_code_(OB_SUCCESS), snapshot_version_(0), schema_version_(0), task_id_(0), execution_id_(0)
ret_code_(OB_SUCCESS), snapshot_version_(0), schema_version_(0), task_id_(0), execution_id_(-1)
{}
~ObDDLBuildSingleReplicaResponseArg() = default;
bool is_valid() const { return OB_INVALID_ID != tenant_id_ && ls_id_.is_valid() && tablet_id_.is_valid()
&& OB_INVALID_ID != source_table_id_ && OB_INVALID_ID != dest_schema_id_
&& snapshot_version_ > 0 && schema_version_ > 0 && task_id_ > 0 && execution_id_ > 0; }
&& snapshot_version_ > 0 && schema_version_ > 0 && task_id_ > 0 && execution_id_ >= 0; }
int assign(const ObDDLBuildSingleReplicaResponseArg &other);
TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(tablet_id), K_(source_table_id), K_(dest_schema_id), K_(ret_code), K_(snapshot_version), K_(schema_version), K_(task_id), K_(execution_id));
public:
@ -7526,7 +7526,7 @@ public:
bool is_valid() const
{
return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && table_key_.is_valid() && start_scn_.is_valid_and_not_min()
&& table_id_ > 0 && execution_id_ > 0 && ddl_task_id_ > 0;
&& table_id_ > 0 && execution_id_ >= 0 && ddl_task_id_ > 0;
}
TO_STRING_KV(K_(tenant_id), K_(ls_id), K_(table_key), K_(start_scn), K_(table_id),
K_(execution_id), K_(ddl_task_id));

2
src/sql/code_generator/ob_static_engine_cg.cpp
View File

@ -6000,7 +6000,7 @@ int ObStaticEngineCG::set_other_properties(const ObLogPlan &log_plan, ObPhysical
if (log_plan.get_stmt()->get_table_items().count() > 0) {
const TableItem *insert_table_item = log_plan.get_stmt()->get_table_item(0);
if (nullptr != insert_table_item) {
int64_t ddl_execution_id = 0;
int64_t ddl_execution_id = -1;
int64_t ddl_task_id = 0;
const ObOptParamHint *opt_params = &log_plan.get_stmt()->get_query_ctx()->get_global_hint().opt_params_;
OZ(opt_params->get_integer_opt_param(ObOptParamHint::DDL_EXECUTION_ID, ddl_execution_id));

2
src/sql/engine/ob_physical_plan.cpp
View File

@ -115,7 +115,7 @@ ObPhysicalPlan::ObPhysicalPlan(MemoryContext &mem_context /* = CURRENT_CONTEXT *
contain_pl_udf_or_trigger_(false),
ddl_schema_version_(0),
ddl_table_id_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_task_id_(0),
is_packed_(false),
has_instead_of_trigger_(false)

2
src/sql/resolver/dml/ob_hint.cpp
View File

@ -601,7 +601,7 @@ bool ObOptParamHint::is_param_val_valid(const OptParamType param_type, const ObO
break;
}
case DDL_EXECUTION_ID: {
is_valid = val.is_int() && (0 < val.get_int());
is_valid = val.is_int() && (0 <= val.get_int());
break;
}
case DDL_TASK_ID: {

8
src/storage/ddl/ob_build_index_task.cpp
View File

@ -41,7 +41,7 @@ using namespace oceanbase::palf;
ObUniqueIndexChecker::ObUniqueIndexChecker()
: is_inited_(false), tenant_id_(OB_INVALID_TENANT_ID), ls_id_(), tablet_id_(),
index_schema_(NULL), data_table_schema_(NULL), execution_id_(0), snapshot_version_(0), task_id_(0),
index_schema_(NULL), data_table_schema_(NULL), execution_id_(-1), snapshot_version_(0), task_id_(0),
is_scan_index_(false)
{
}
@ -54,7 +54,7 @@ int ObUniqueIndexChecker::init(
const ObTableSchema *data_table_schema,
const ObTableSchema *index_schema,
const int64_t task_id,
const uint64_t execution_id,
const int64_t execution_id,
const int64_t snapshot_version)
{
int ret = OB_SUCCESS;
@ -593,7 +593,7 @@ int ObUniqueIndexChecker::wait_trans_end(ObIDag *dag)
ObUniqueCheckingDag::ObUniqueCheckingDag()
: ObIDag(ObDagType::DAG_TYPE_UNIQUE_CHECKING), is_inited_(false), tenant_id_(OB_INVALID_TENANT_ID), tablet_id_(), is_scan_index_(false),
schema_guard_(share::schema::ObSchemaMgrItem::MOD_UNIQ_CHECK), index_schema_(nullptr), data_table_schema_(nullptr), callback_(nullptr),
execution_id_(0), snapshot_version_(0), compat_mode_(lib::Worker::CompatMode::INVALID)
execution_id_(-1), snapshot_version_(0), compat_mode_(lib::Worker::CompatMode::INVALID)
{
}
@ -613,7 +613,7 @@ int ObUniqueCheckingDag::init(
const uint64_t index_table_id,
const int64_t schema_version,
const int64_t task_id,
const uint64_t execution_id,
const int64_t execution_id,
const int64_t snapshot_version)
{
int ret = OB_SUCCESS;

10
src/storage/ddl/ob_build_index_task.h
View File

@ -38,7 +38,7 @@ public:
const share::schema::ObTableSchema *data_table_schema,
const share::schema::ObTableSchema *index_schema,
const int64_t task_id,
const uint64_t execution_id = OB_INVALID_ID,
const int64_t execution_id = -1,
const int64_t snapshot_version = OB_INVALID_VERSION);
int check_unique_index(share::ObIDag *dag);
private:
@ -109,7 +109,7 @@ private:
common::ObTabletID tablet_id_;
const share::schema::ObTableSchema *index_schema_;
const share::schema::ObTableSchema *data_table_schema_;
uint64_t execution_id_;
int64_t execution_id_;
int64_t snapshot_version_;
int64_t task_id_;
ObTabletHandle tablet_handle_;
@ -159,11 +159,11 @@ public:
const bool is_scan_index,
const uint64_t index_table_id, const int64_t schema_version,
const int64_t task_id,
const uint64_t execution_id = OB_INVALID_ID,
const int64_t execution_id = -1,
const int64_t snapshot_version = OB_INVALID_VERSION);
const share::schema::ObTableSchema *get_index_schema() const { return index_schema_; }
const share::schema::ObTableSchema *get_data_table_schema() const { return data_table_schema_; }
uint64_t get_execution_id() const { return execution_id_; }
int64_t get_execution_id() const { return execution_id_; }
int64_t get_snapshot_version() const { return snapshot_version_; }
int64_t get_task_id() const { return task_id_; }
bool get_is_scan_index() const { return is_scan_index_; }
@ -194,7 +194,7 @@ private:
const share::schema::ObTableSchema *index_schema_;
const share::schema::ObTableSchema *data_table_schema_;
ObIUniqueCheckingCompleteCallback *callback_;
uint64_t execution_id_;
int64_t execution_id_;
int64_t snapshot_version_;
int64_t task_id_;
lib::Worker::CompatMode compat_mode_;

6
src/storage/ddl/ob_complement_data_task.h
View File

@ -42,7 +42,7 @@ public:
source_tablet_id_(ObTabletID::INVALID_TABLET_ID), dest_tablet_id_(ObTabletID::INVALID_TABLET_ID),
data_table_schema_(nullptr), hidden_table_schema_(nullptr), allocator_("CompleteDataPar"),
row_store_type_(common::ENCODING_ROW_STORE), schema_version_(0), snapshot_version_(0),
concurrent_cnt_(0), task_id_(0), execution_id_(0), tablet_task_id_(0),
concurrent_cnt_(0), task_id_(0), execution_id_(-1), tablet_task_id_(0),
compat_mode_(lib::Worker::CompatMode::INVALID)
{}
~ObComplementDataParam() { destroy(); }
@ -54,7 +54,7 @@ public:
return common::OB_INVALID_TENANT_ID != tenant_id_ && ls_id_.is_valid() && source_tablet_id_.is_valid()
&& dest_tablet_id_.is_valid() && OB_NOT_NULL(data_table_schema_) && OB_NOT_NULL(hidden_table_schema_)
&& 0 != concurrent_cnt_ && snapshot_version_ > 0 && compat_mode_ != lib::Worker::CompatMode::INVALID
&& execution_id_ > 0 && tablet_task_id_ > 0;
&& execution_id_ >= 0 && tablet_task_id_ > 0;
}
int get_hidden_table_key(ObITable::TableKey &table_key) const;
void destroy()
@ -79,7 +79,7 @@ public:
snapshot_version_ = 0;
concurrent_cnt_ = 0;
task_id_ = 0;
execution_id_ = 0;
execution_id_ = -1;
tablet_task_id_ = 0;
compat_mode_ = lib::Worker::CompatMode::INVALID;
}

2
src/storage/ddl/ob_ddl_clog.cpp
View File

@ -265,7 +265,7 @@ DEFINE_GET_SERIALIZE_SIZE(ObDDLClogHeader)
}
ObDDLStartLog::ObDDLStartLog()
: table_key_(), cluster_version_(0), execution_id_(0)
: table_key_(), cluster_version_(0), execution_id_(-1)
{
}

4
src/storage/ddl/ob_ddl_merge_task.cpp
View File

@ -403,7 +403,7 @@ int ObDDLTableMergeTask::process()
ret = OB_ERR_UNEXPECTED;
LOG_WARN("ddl major sstable is null", K(ret), K(ddl_param));
} else if (merge_param_.table_id_ > 0
&& merge_param_.execution_id_ > 0
&& merge_param_.execution_id_ >= 0
&& OB_FAIL(ObTabletDDLUtil::report_ddl_checksum(merge_param_.ls_id_,
merge_param_.tablet_id_,
merge_param_.table_id_,
@ -777,7 +777,7 @@ int ObTabletDDLUtil::report_ddl_checksum(const share::ObLSID &ls_id,
const ObTableSchema *table_schema = nullptr;
const uint64_t tenant_id = MTL_ID();
if (OB_UNLIKELY(!ls_id.is_valid() || !tablet_id.is_valid() || OB_INVALID_ID == ddl_task_id
|| !is_valid_id(table_id) || 0 == table_id || execution_id <= 0)) {
|| !is_valid_id(table_id) || 0 == table_id || execution_id < 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(ls_id), K(tablet_id), K(table_id), K(execution_id));
} else if (!is_valid_tenant_id(tenant_id) || OB_ISNULL(sql_proxy) || OB_ISNULL(schema_service)) {

2
src/storage/ddl/ob_ddl_merge_task.h
View File

@ -46,7 +46,7 @@ public:
is_commit_(false),
start_scn_(share::SCN::min_scn()),
table_id_(0),
execution_id_(0),
execution_id_(-1),
ddl_task_id_(0)
{ }
bool is_valid() const

2
src/storage/ddl/ob_ddl_redo_log_writer.cpp
View File

@ -972,7 +972,7 @@ int ObDDLSSTableRedoWriter::start_ddl_redo(const ObITable::TableKey &table_key,
if (OB_UNLIKELY(!is_inited_)) {
ret = OB_NOT_INIT;
LOG_WARN("ObDDLSSTableRedoWriter has not been inited", K(ret));
} else if (OB_UNLIKELY(!table_key.is_valid() || execution_id <= 0)) {
} else if (OB_UNLIKELY(!table_key.is_valid() || execution_id < 0)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid arguments", K(ret), K(table_key), K(execution_id));
} else if (OB_FAIL(log.init(table_key, GET_MIN_CLUSTER_VERSION(), execution_id))) {

6
src/storage/ddl/ob_direct_insert_sstable_ctx.cpp
View File

@ -38,7 +38,7 @@ using namespace oceanbase::sql;
/*************** ObSSTableInsertTabletParam *****************/
ObSSTableInsertTabletParam::ObSSTableInsertTabletParam()
: context_id_(0), ls_id_(), tablet_id_(), table_id_(0), write_major_(false),
task_cnt_(0), schema_version_(0), snapshot_version_(0), execution_id_(0), ddl_task_id_(0)
task_cnt_(0), schema_version_(0), snapshot_version_(0), execution_id_(-1), ddl_task_id_(0)
{
}
@ -56,7 +56,7 @@ bool ObSSTableInsertTabletParam::is_valid() const
&& table_id_ > 0
&& task_cnt_ >= 0
&& schema_version_ > 0
&& execution_id_ > 0
&& execution_id_ >= 0
&& ddl_task_id_ > 0;
return bret;
}
@ -735,7 +735,7 @@ int ObSSTableInsertTabletContext::get_table_key(ObITable::TableKey &table_key)
ObSSTableInsertTableParam::ObSSTableInsertTableParam()
: exec_ctx_(nullptr), context_id_(0), dest_table_id_(OB_INVALID_ID), write_major_(false), schema_version_(0),
snapshot_version_(0), task_cnt_(0), execution_id_(0), ddl_task_id_(0), ls_tablet_ids_()
snapshot_version_(0), task_cnt_(0), execution_id_(-1), ddl_task_id_(0), ls_tablet_ids_()
{
}

2
src/storage/ddl/ob_direct_insert_sstable_ctx.h
View File

@ -148,7 +148,7 @@ public:
int assign(const ObSSTableInsertTableParam &other);
bool is_valid() const { return exec_ctx_ != nullptr && OB_INVALID_ID != dest_table_id_
&& schema_version_ >= 0 && snapshot_version_ >= 0 && task_cnt_ >= 0
&& execution_id_ > 0 && ddl_task_id_ > 0 && ls_tablet_ids_.count() > 0; }
&& execution_id_ >= 0 && ddl_task_id_ > 0 && ls_tablet_ids_.count() > 0; }
TO_STRING_KV(K_(context_id), K_(dest_table_id), K_(write_major), K_(schema_version), K_(snapshot_version),
K_(task_cnt), K_(execution_id), K_(ddl_task_id), K_(ls_tablet_ids));
public:

6
src/storage/ddl/ob_tablet_ddl_kv_mgr.cpp
View File

@ -30,7 +30,7 @@ using namespace oceanbase::storage;
ObTabletDDLKvMgr::ObTabletDDLKvMgr()
: is_inited_(false), success_start_scn_(SCN::min_scn()), ls_id_(), tablet_id_(), table_key_(), cluster_version_(0),
start_scn_(SCN::min_scn()), max_freeze_scn_(SCN::min_scn()),
table_id_(0), execution_id_(0), head_(0), tail_(0), lock_(ObLatchIds::TABLET_DDL_KV_MGR_LOCK), ref_cnt_(0)
table_id_(0), execution_id_(-1), head_(0), tail_(0), lock_(ObLatchIds::TABLET_DDL_KV_MGR_LOCK), ref_cnt_(0)
{
MEMSET(ddl_kvs_, 0, MAX_DDL_KV_CNT_IN_STORAGE * sizeof(ddl_kvs_[0]));
}
@ -61,7 +61,7 @@ void ObTabletDDLKvMgr::destroy()
start_scn_.set_min();
max_freeze_scn_.set_min();
table_id_ = 0;
execution_id_ = 0;
execution_id_ = -1;
success_start_scn_.set_min();
is_inited_ = false;
}
@ -345,7 +345,7 @@ void ObTabletDDLKvMgr::cleanup_unlock()
start_scn_.set_min();
max_freeze_scn_.set_min();
table_id_ = 0;
execution_id_ = 0;
execution_id_ = -1;
success_start_scn_.set_min();
}

6
src/storage/ob_storage_struct.cpp
View File

@ -222,7 +222,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
ddl_checkpoint_scn_(SCN::min_scn()),
ddl_start_scn_(SCN::min_scn()),
ddl_snapshot_version_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_cluster_version_(0),
allow_duplicate_sstable_(false),
tx_data_(),
@ -255,7 +255,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
ddl_checkpoint_scn_(SCN::min_scn()),
ddl_start_scn_(SCN::min_scn()),
ddl_snapshot_version_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_cluster_version_(0),
allow_duplicate_sstable_(allow_duplicate_sstable),
tx_data_(),
@ -286,7 +286,7 @@ ObUpdateTableStoreParam::ObUpdateTableStoreParam(
ddl_checkpoint_scn_(SCN::min_scn()),
ddl_start_scn_(SCN::min_scn()),
ddl_snapshot_version_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_cluster_version_(0),
allow_duplicate_sstable_(false),
tx_data_(),

10
src/storage/tablet/ob_tablet_meta.cpp
View File

@ -56,7 +56,7 @@ ObTabletMeta::ObTabletMeta()
ddl_start_scn_(SCN::min_scn()),
ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
max_sync_storage_schema_version_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_cluster_version_(0),
is_inited_(false)
{
@ -113,7 +113,7 @@ int ObTabletMeta::init(
ddl_start_scn_.set_min();
ddl_snapshot_version_ = 0;
max_sync_storage_schema_version_ = max_sync_storage_schema_version;
ddl_execution_id_ = 0;
ddl_execution_id_ = -1;
ddl_cluster_version_ = 0;
report_status_.merge_snapshot_version_ = snapshot_version;
@ -356,7 +356,7 @@ void ObTabletMeta::reset()
ddl_start_scn_.set_min();
ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
max_sync_storage_schema_version_ = 0;
ddl_execution_id_ = 0;
ddl_execution_id_ = -1;
ddl_cluster_version_ = 0;
is_inited_ = false;
}
@ -745,7 +745,7 @@ ObMigrationTabletParam::ObMigrationTabletParam()
ddl_start_scn_(SCN::min_scn()),
ddl_snapshot_version_(OB_INVALID_TIMESTAMP),
max_sync_storage_schema_version_(0),
ddl_execution_id_(0),
ddl_execution_id_(-1),
ddl_cluster_version_(0)
{
}
@ -958,7 +958,7 @@ void ObMigrationTabletParam::reset()
ddl_start_scn_.set_min();
ddl_snapshot_version_ = OB_INVALID_TIMESTAMP;
max_sync_storage_schema_version_ = 0;
ddl_execution_id_ = 0;
ddl_execution_id_ = -1;
ddl_cluster_version_ = 0;
}

2
src/storage/tablet/ob_tablet_meta.h
View File

@ -78,7 +78,7 @@ public:
const share::SCN ddl_checkpoint_scn = share::SCN::min_scn(),
const share::SCN ddl_start_scn = share::SCN::min_scn(),
const int64_t ddl_snapshot_version = 0,
const int64_t ddl_execution_id = 0,
const int64_t ddl_execution_id = -1,
const int64_t ddl_cluster_version = 0);
int init(
common::ObIAllocator &allocator,