hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
4eb850e27e63da972cb211f621aa202a9e4da3c1
oceanbase/src/rootserver/ddl_task/ob_ddl_task.h
Hongqin-Li 4eb850e27e Query __all_ddl_task_status in tenant space
2023-07-11 04:18:36 +00:00

695 lines
25 KiB
C++
Executable File
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#ifndef OCEANBASE_ROOTSERVER_OB_DDL_TASK_H_
#define OCEANBASE_ROOTSERVER_OB_DDL_TASK_H_
#include "lib/container/ob_array.h"
#include "lib/thread/ob_async_task_queue.h"
#include "lib/trace/ob_trace.h"
#include "share/ob_ddl_task_executor.h"
#include "share/ob_rpc_struct.h"
#include "share/schema/ob_schema_struct.h"
#include "share/ob_ddl_common.h"
#include "share/longops_mgr/ob_ddl_longops.h"
#include "rootserver/ddl_task/ob_ddl_single_replica_executor.h"
namespace oceanbase
{
namespace rootserver
{
class ObRootService;
struct ObDDLTaskRecord;
struct ObDDLTaskKey final
{
public:
ObDDLTaskKey();
ObDDLTaskKey(const uint64_t tenant_id, const int64_t object_id, const int64_t schema_version);
~ObDDLTaskKey() = default;
uint64_t hash() const;
int hash(uint64_t &hash_val) const { hash_val = hash(); return OB_SUCCESS; }
bool operator==(const ObDDLTaskKey &other) const;
bool is_valid() const { return OB_INVALID_TENANT_ID != tenant_id_ && OB_INVALID_ID != object_id_ && schema_version_ > 0; }
int assign(const ObDDLTaskKey &other);
TO_STRING_KV(K_(tenant_id), K_(object_id), K_(schema_version));
public:
uint64_t tenant_id_;
int64_t object_id_;
int64_t schema_version_;
};
struct ObDDLTaskID final
{
public:
ObDDLTaskID();
ObDDLTaskID(const uint64_t tenant_id, const int64_t task_id);
~ObDDLTaskID() = default;
uint64_t hash() const;
int hash(uint64_t &hash_val) const { hash_val = hash(); return OB_SUCCESS; }
bool operator==(const ObDDLTaskID &other) const;
bool operator!=(const ObDDLTaskID &other) const;
bool is_valid() const { return OB_INVALID_TENANT_ID != tenant_id_ && task_id_ > 0; }
int assign(const ObDDLTaskID &other);
TO_STRING_KV(K_(tenant_id), K_(task_id));
public:
uint64_t tenant_id_;
int64_t task_id_;
};
struct ObDDLTaskRecord final
{
public:
ObDDLTaskRecord() { reset(); }
~ObDDLTaskRecord() {}
bool is_valid() const;
void reset();
TO_STRING_KV(K_(task_id), K_(parent_task_id), K_(ddl_type), K_(trace_id), K_(task_status), K_(tenant_id), K_(object_id),
K_(schema_version), K_(target_object_id), K_(snapshot_version), K_(message), K_(task_version), K_(ret_code), K_(execution_id));
public:
static const int64_t MAX_MESSAGE_LENGTH = 4096;
typedef common::ObFixedLengthString<MAX_MESSAGE_LENGTH> TaskMessage;
public:
uint64_t gmt_create_;
int64_t task_id_;
int64_t parent_task_id_;
share::ObDDLType ddl_type_;
common::ObCurTraceId::TraceId trace_id_;
int64_t task_status_;
uint64_t tenant_id_;
uint64_t object_id_;
uint64_t schema_version_;
uint64_t target_object_id_;
int64_t snapshot_version_;
ObString message_;
int64_t task_version_;
int64_t ret_code_;
int64_t execution_id_;
ObString ddl_stmt_str_;
};
struct ObDDLTaskInfo final
{
public:
ObDDLTaskInfo() : row_scanned_(0), row_inserted_(0) {}
~ObDDLTaskInfo() {}
TO_STRING_KV(K_(row_scanned), K_(row_inserted));
public:
int64_t row_scanned_;
int64_t row_inserted_;
};
struct ObDDLTaskSerializeField final
{
OB_UNIS_VERSION(1);
public:
TO_STRING_KV(K_(task_version), K_(parallelism), K_(data_format_version), K_(consumer_group_id), K_(is_abort));
ObDDLTaskSerializeField() : task_version_(0), parallelism_(0), data_format_version_(0), consumer_group_id_(0), is_abort_(false) {}
ObDDLTaskSerializeField(const int64_t task_version,
const int64_t parallelism,
const int64_t data_format_version,
const int64_t consumer_group_id,
const bool is_abort);
~ObDDLTaskSerializeField() = default;
void reset();
public:
int64_t task_version_;
int64_t parallelism_;
int64_t data_format_version_;
int64_t consumer_group_id_;
bool is_abort_;
};
struct ObCreateDDLTaskParam final
{
public:
ObCreateDDLTaskParam();
ObCreateDDLTaskParam(const uint64_t tenant_id,
const share::ObDDLType &type,
const ObTableSchema *src_table_schema,
const ObTableSchema *dest_table_schema,
const int64_t object_id,
const int64_t schema_version,
const int64_t parallelism,
const int64_t consumer_group_id,
ObIAllocator *allocator,
const obrpc::ObDDLArg *ddl_arg = nullptr,
const int64_t parent_task_id = 0,
const int64_t task_id = 0);
~ObCreateDDLTaskParam() = default;
bool is_valid() const { return OB_INVALID_ID != tenant_id_ && type_ > share::DDL_INVALID
&& type_ < share::DDL_MAX && nullptr != allocator_; }
TO_STRING_KV(K_(tenant_id), K_(object_id), K_(schema_version), K_(parallelism), K_(consumer_group_id), K_(parent_task_id), K_(task_id),
K_(type), KPC_(src_table_schema), KPC_(dest_table_schema), KPC_(ddl_arg));
public:
uint64_t tenant_id_;
int64_t object_id_;
int64_t schema_version_;
int64_t parallelism_;
int64_t consumer_group_id_;
int64_t parent_task_id_;
int64_t task_id_;
share::ObDDLType type_;
const ObTableSchema *src_table_schema_;
const ObTableSchema *dest_table_schema_;
const obrpc::ObDDLArg *ddl_arg_;
common::ObIAllocator *allocator_;
};
class ObDDLTaskRecordOperator final
{
public:
static int update_task_status(
common::ObISQLClient &proxy,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t task_status);
static int update_snapshot_version(
common::ObISQLClient &sql_client,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t snapshot_version);
static int update_ret_code(
common::ObISQLClient &sql_client,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t ret_code);
static int update_execution_id(
common::ObISQLClient &sql_client,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t execution_id);
static int update_message(
common::ObISQLClient &proxy,
const uint64_t tenant_id,
const int64_t task_id,
const ObString &message);
static int update_status_and_message(
common::ObISQLClient &proxy,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t task_status,
ObString &message);
static int delete_record(
common::ObMySQLProxy &proxy,
const uint64_t tenant_id,
const int64_t task_id);
static int select_for_update(
common::ObMySQLTransaction &trans,
const uint64_t tenant_id,
const int64_t task_id,
int64_t &task_status,
int64_t &execution_id);
static int get_ddl_task_record(
const uint64_t tenant_id,
const int64_t task_id,
common::ObMySQLProxy &proxy,
common::ObIAllocator &allocator,
ObDDLTaskRecord &record);
static int get_all_ddl_task_record(
common::ObMySQLProxy &proxy,
common::ObIAllocator &allocator,
common::ObIArray<ObDDLTaskRecord> &records);
static int check_task_id_exist(
common::ObMySQLProxy &proxy,
const uint64_t tenant_id,
const int64_t task_id,
bool &exist);
static int check_is_adding_constraint(
common::ObMySQLProxy *proxy,
common::ObIAllocator &allocator,
const uint64_t tenant_id,
const uint64_t table_id,
bool &is_building);
static int check_has_long_running_ddl(
common::ObMySQLProxy *proxy,
const uint64_t tenant_id,
const uint64_t table_id,
bool &has_long_running_ddl);
static int check_has_conflict_ddl(
common::ObMySQLProxy *proxy,
const uint64_t tenant_id,
const uint64_t table_id,
const int64_t task_id,
const share::ObDDLType ddl_type,
bool &has_conflict_ddl);
static int check_has_index_task(
common::ObISQLClient &proxy,
const uint64_t tenant_id,
const uint64_t data_table_id,
const uint64_t index_table_id,
bool &has_index_task);
static int insert_record(
common::ObISQLClient &proxy,
ObDDLTaskRecord &record);
static int to_hex_str(const ObString &src, ObSqlString &dst);
static int kill_task_inner_sql(
common::ObMySQLProxy &proxy,
const common::ObCurTraceId::TraceId &trace_id,
const uint64_t tenant_id,
const int64_t task_id,
const int64_t snapshot_version,
const common::ObAddr &sql_exec_addr);
private:
static int fill_task_record(
const uint64_t tenant_id,
const common::sqlclient::ObMySQLResult *result_row,
common::ObIAllocator &allocator,
ObDDLTaskRecord &task_record);
static int64_t get_record_id(share::ObDDLType ddl_type, int64_t origin_id);
static int kill_inner_sql(
common::ObMySQLProxy &proxy,
const uint64_t tenant_id,
const uint64_t session_id);
static int get_task_record(
const uint64_t tenant_id,
const ObSqlString &sql_string,
common::ObMySQLProxy &proxy,
common::ObIAllocator &allocator,
common::ObIArray<ObDDLTaskRecord> &records);
};
class ObDDLWaitTransEndCtx
{
public:
enum WaitTransType
{
MIN_WAIT_TYPE = 0,
WAIT_SCHEMA_TRANS,
WAIT_SSTABLE_TRANS,
MAX_WAIT_TYPE
};
public:
ObDDLWaitTransEndCtx();
~ObDDLWaitTransEndCtx();
int init(
const uint64_t tenant_id,
const uint64_t table_id,
const WaitTransType wait_trans_type,
const int64_t wait_version);
void reset();
bool is_inited() const { return is_inited_; }
int try_wait(bool &is_trans_end, int64_t &snapshot_version, const bool need_wait_trans_end = true);
transaction::ObTransID get_pending_tx_id() const { return pending_tx_id_; }
TO_STRING_KV(K(is_inited_), K_(tenant_id), K(table_id_), K(is_trans_end_), K(wait_type_),
K(wait_version_), K_(pending_tx_id), K(tablet_ids_.count()), K(snapshot_array_.count()));
private:
static bool is_wait_trans_type_valid(const WaitTransType wait_trans_type);
int get_snapshot_check_list(
common::ObIArray<common::ObTabletID> &need_check_tablets,
ObIArray<int64_t> &tablet_pos_indexes);
int get_snapshot(int64_t &snapshot_version);
// check if all transactions before a schema version have ended
int check_schema_trans_end(
const int64_t schema_version,
const common::ObIArray<common::ObTabletID> &tablet_ids,
common::ObIArray<int> &ret_array,
common::ObIArray<int64_t> &snapshot_array,
const uint64_t tenant_id,
obrpc::ObSrvRpcProxy *rpc_proxy,
share::ObLocationService *location_service,
const bool need_wait_trans_end);
// check if all transactions before a timestamp have ended
int check_sstable_trans_end(
const uint64_t tenant_id,
const int64_t sstable_exist_ts,
const common::ObIArray<common::ObTabletID> &tablet_ids,
obrpc::ObSrvRpcProxy *rpc_proxy,
share::ObLocationService *location_service,
common::ObIArray<int> &ret_array,
common::ObIArray<int64_t> &snapshot_array);
private:
static const int64_t INDEX_SNAPSHOT_VERSION_DIFF = 100 * 1000 * 1000; // 100ms
bool is_inited_;
uint64_t tenant_id_;
uint64_t table_id_;
bool is_trans_end_;
WaitTransType wait_type_;
int64_t wait_version_;
transaction::ObTransID pending_tx_id_;
common::ObArray<common::ObTabletID> tablet_ids_;
common::ObArray<int64_t> snapshot_array_;
};
class ObDDLTask;
struct ObDDLTracing final
{
OB_UNIS_VERSION(1);
public:
ObDDLTracing() = delete;
explicit ObDDLTracing(const ObDDLTask *ddl_task)
: trace_ctx_(), task_span_id_(), status_span_id_(), parent_task_span_id_(),
task_start_ts_(0), status_start_ts_(0), parent_task_span_(nullptr),
task_span_(nullptr), status_span_(nullptr), task_(ddl_task),
is_status_span_begin_(false), is_status_span_end_(false), is_task_span_flushed_(false)
{}
bool is_valid() const
{
return task_span_id_.low_ != 0 && task_span_id_.high_ != 0 &&
status_span_id_.low_ != 0 && status_span_id_.high_ != 0 &&
parent_task_span_id_.low_ != 0 && parent_task_span_id_.high_ != 0 &&
task_start_ts_ != 0 && status_start_ts_ != 0;
}
void open();
void open_for_recovery();
void restore_span_hierarchy();
void release_span_hierarchy();
void end_status_span();
void close();
private:
void init_span_id(trace::ObSpanCtx *span);
void init_task_span();
void init_status_span();
trace::ObSpanCtx* begin_task_span();
void end_task_span();
trace::ObSpanCtx* begin_status_span(const share::ObDDLTaskStatus status);
trace::ObSpanCtx* restore_parent_task_span();
trace::ObSpanCtx* restore_task_span();
trace::ObSpanCtx* restore_status_span();
void record_trace_ctx();
void record_parent_task_span(trace::ObSpanCtx *span);
void record_task_span(trace::ObSpanCtx *span);
void record_status_span(trace::ObSpanCtx *span);
private:
// members that will be serialized to ddl task record
trace::FltTransCtx trace_ctx_;
trace::UUID task_span_id_; // build index task, drop index task etc
trace::UUID status_span_id_; // status: prepare, succ etc
trace::UUID parent_task_span_id_;
int64_t task_start_ts_;
int64_t status_start_ts_;
// members that will not be serialized
trace::ObSpanCtx *parent_task_span_;
trace::ObSpanCtx *task_span_;
trace::ObSpanCtx *status_span_;
const ObDDLTask *task_;
bool is_status_span_begin_;
bool is_status_span_end_;
bool is_task_span_flushed_;
};
struct ObDDLTaskStatInfo final
{
public:
ObDDLTaskStatInfo();
~ObDDLTaskStatInfo() = default;
int init(const char *&ddl_type_str, const uint64_t table_id);
TO_STRING_KV(K_(start_time), K_(finish_time), K_(time_remaining), K_(percentage),
K_(op_name), K_(target), K_(message));
public:
int64_t start_time_;
int64_t finish_time_;
int64_t time_remaining_;
int64_t percentage_;
char op_name_[common::MAX_LONG_OPS_NAME_LENGTH];
char target_[common::MAX_LONG_OPS_TARGET_LENGTH];
char message_[common::MAX_LONG_OPS_MESSAGE_LENGTH];
};
class ObDDLTask : public common::ObDLinkBase<ObDDLTask>
{
public:
explicit ObDDLTask(const share::ObDDLType task_type)
: lock_(), ddl_tracing_(this), is_inited_(false), need_retry_(true), is_running_(false), is_abort_(false),
task_type_(task_type), trace_id_(), tenant_id_(0), object_id_(0), schema_version_(0),
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),
longops_stat_(nullptr), gmt_create_(0), stat_info_(), delay_schedule_time_(0), next_schedule_ts_(0),
execution_id_(-1), sql_exec_addr_(), start_time_(0), data_format_version_(0)
{}
virtual ~ObDDLTask() {}
virtual int process() = 0;
virtual bool is_valid() const { return is_inited_; }
typedef common::ObCurTraceId::TraceId TraceId;
virtual const TraceId &get_trace_id() const { return trace_id_; }
virtual int set_trace_id(const TraceId &trace_id) { return trace_id_.set(trace_id.get()); }
virtual bool need_retry() const { return need_retry_; };
share::ObDDLType get_task_type() const { return task_type_; }
void set_not_running() { ATOMIC_SET(&is_running_, false); }
void set_task_status(const share::ObDDLTaskStatus new_status) {task_status_ = new_status; }
void set_is_abort(const bool is_abort) { is_abort_ = is_abort; }
bool get_is_abort() { return is_abort_; }
void set_consumer_group_id(const int64_t group_id) { consumer_group_id_ = group_id; }
bool try_set_running() { return !ATOMIC_CAS(&is_running_, false, true); }
uint64_t get_tenant_id() const { return tenant_id_; }
uint64_t get_object_id() const { return object_id_; }
int64_t get_schema_version() const { return schema_version_; }
uint64_t get_target_object_id() const { return target_object_id_; }
int64_t get_task_status() const { return task_status_; }
int64_t get_snapshot_version() const { return snapshot_version_; }
int get_ddl_type_str(const int64_t ddl_type, const char *&ddl_type_str);
int64_t get_ret_code() const { return ret_code_; }
int64_t get_task_id() const { return task_id_; }
ObDDLTaskID get_ddl_task_id() const { return ObDDLTaskID(tenant_id_, task_id_); }
ObDDLTaskKey get_task_key() const { return ObDDLTaskKey(tenant_id_, target_object_id_, schema_version_); }
int64_t get_parent_task_id() const { return parent_task_id_; }
int64_t get_task_version() const { return task_version_; }
int64_t get_parallelism() const { return parallelism_; }
uint64_t get_gmt_create() const { return gmt_create_; }
void set_gmt_create(uint64_t gmt_create) { gmt_create_ = gmt_create; }
static int deep_copy_table_arg(common::ObIAllocator &allocator,
const obrpc::ObDDLArg &source_arg,
obrpc::ObDDLArg &dest_arg);
void set_longops_stat(share::ObDDLLongopsStat *longops_stat) { longops_stat_ = longops_stat; }
share::ObDDLLongopsStat *get_longops_stat() const { return longops_stat_; }
int64_t get_data_format_version() const { return data_format_version_; }
static int fetch_new_task_id(ObMySQLProxy &sql_proxy, const uint64_t tenant_id, int64_t &new_task_id);
virtual int serialize_params_to_message(char *buf, const int64_t buf_size, int64_t &pos) const;
virtual int deserlize_params_from_message(const uint64_t tenant_id, const char *buf, const int64_t buf_size, int64_t &pos);
virtual int64_t get_serialize_param_size() const;
const ObString &get_ddl_stmt_str() const { return ddl_stmt_str_; }
int set_ddl_stmt_str(const ObString &ddl_stmt_str);
int convert_to_record(ObDDLTaskRecord &task_record, common::ObIAllocator &allocator);
int switch_status(const share::ObDDLTaskStatus new_status, const bool enable_flt, const int ret_code);
int refresh_status();
int refresh_schema_version();
int remove_task_record();
int report_error_code(const ObString &forward_user_message, const int64_t affected_rows = 0);
int check_ddl_task_is_cancel(const TraceId &trace_id, bool &is_cancel);
int wait_trans_end(
ObDDLWaitTransEndCtx &wait_trans_ctx,
const share::ObDDLTaskStatus next_task_status);
lib::Worker::CompatMode get_compat_mode() { return compat_mode_; }
int batch_release_snapshot(
const int64_t snapshot_version,
const common::ObIArray<common::ObTabletID> &tablet_ids);
void set_sys_task_id(const TraceId &sys_task_id) { sys_task_id_ = sys_task_id; }
void set_sql_exec_addr(const common::ObAddr &addr) { sql_exec_addr_ = addr; }
const TraceId &get_sys_task_id() const { return sys_task_id_; }
virtual int collect_longops_stat(share::ObLongopsValue &value);
void calc_next_schedule_ts(const int ret_code, const int64_t total_task_cnt);
bool need_schedule() { return next_schedule_ts_ <= ObTimeUtility::current_time(); }
bool is_replica_build_need_retry(const int ret_code);
int64_t get_execution_id() const;
static int push_execution_id(const uint64_t tenant_id, const int64_t task_id, int64_t &new_execution_id);
void check_ddl_task_execute_too_long();
static bool check_is_load_data(share::ObDDLType task_type);
virtual bool support_longops_monitoring() const { return false; }
int cleanup();
virtual int cleanup_impl() = 0;
virtual void flt_set_task_span_tag() const = 0;
virtual void flt_set_status_span_tag() const = 0;
int update_task_record_status_and_msg(common::ObISQLClient &proxy, const share::ObDDLTaskStatus real_new_status);
#ifdef ERRSIM
int check_errsim_error();
#endif
VIRTUAL_TO_STRING_KV(
K(is_inited_), K(need_retry_), K(task_type_), K(trace_id_),
K(tenant_id_), K(object_id_), K(schema_version_),
K(target_object_id_), K(task_status_), K(snapshot_version_),
K_(ret_code), K_(task_id), K_(parent_task_id), K_(parent_task_key),
K_(task_version), K_(parallelism), K_(ddl_stmt_str), K_(compat_mode),
K_(sys_task_id), K_(err_code_occurence_cnt), K_(stat_info),
K_(next_schedule_ts), K_(delay_schedule_time), K(execution_id_), K(sql_exec_addr_), K_(data_format_version), K(consumer_group_id_));
protected:
int gather_redefinition_stats(const uint64_t tenant_id,
const int64_t task_id,
ObMySQLProxy &sql_proxy,
int64_t &row_scanned,
int64_t &row_sorted,
int64_t &row_inserted);
int gather_scanned_rows(
const uint64_t tenant_id,
const int64_t task_id,
ObMySQLProxy &sql_proxy,
int64_t &row_scanned);
int gather_sorted_rows(
const uint64_t tenant_id,
const int64_t task_id,
ObMySQLProxy &sql_proxy,
int64_t &row_sorted);
int gather_inserted_rows(
const uint64_t tenant_id,
const int64_t task_id,
ObMySQLProxy &sql_proxy,
int64_t &row_inserted);
int copy_longops_stat(share::ObLongopsValue &value);
virtual bool is_error_need_retry(const int ret_code)
{
return !share::ObIDDLTask::in_ddl_retry_black_list(ret_code) && (share::ObIDDLTask::in_ddl_retry_white_list(ret_code)
|| MAX_ERR_TOLERANCE_CNT > ++err_code_occurence_cnt_);
}
int init_ddl_task_monitor_info(const uint64_t target_table_id);
protected:
static const int64_t MAX_ERR_TOLERANCE_CNT = 3L; // Max torlerance count for error code.
static const int64_t TASK_EXECUTE_TIME_THRESHOLD = 3 * 24 * 60 * 60 * 1000000L; // 3 days
common::TCRWLock lock_;
ObDDLTracing ddl_tracing_;
bool is_inited_;
bool need_retry_;
bool is_running_;
bool is_abort_;
share::ObDDLType task_type_;
TraceId trace_id_;
uint64_t tenant_id_;
uint64_t object_id_;
uint64_t schema_version_;
uint64_t target_object_id_;
share::ObDDLTaskStatus task_status_;
int64_t snapshot_version_;
int64_t ret_code_;
int64_t task_id_;
int64_t parent_task_id_;
ObDDLTaskKey parent_task_key_;
int64_t task_version_;
int64_t parallelism_;
ObString ddl_stmt_str_;
common::ObArenaAllocator allocator_;
lib::Worker::CompatMode compat_mode_;
TraceId sys_task_id_;
int64_t err_code_occurence_cnt_; // occurence count for all error return codes not in white list.
share::ObDDLLongopsStat *longops_stat_;
uint64_t gmt_create_;
ObDDLTaskStatInfo stat_info_;
int64_t delay_schedule_time_;
int64_t next_schedule_ts_;
int64_t execution_id_; // guarded by lock_
common::ObAddr sql_exec_addr_;
int64_t start_time_;
int64_t data_format_version_;
int64_t consumer_group_id_;
};
enum ColChecksumStat
{
CCS_INVALID = 0,
CCS_NOT_MASTER,
CCS_SUCCEED,
CCS_FAILED,
};
struct PartitionColChecksumStat
{
PartitionColChecksumStat()
: tablet_id_(),
col_checksum_stat_(CCS_INVALID),
snapshot_(-1),
execution_id_(-1),
ret_code_(OB_SUCCESS)
{}
void reset() {
tablet_id_.reset();
col_checksum_stat_ = CCS_INVALID;
snapshot_ = -1;
execution_id_ = -1;
ret_code_ = common::OB_SUCCESS;
table_id_ = common::OB_INVALID_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),
K_(execution_id),
K_(table_id));
ObTabletID tablet_id_; // may be data table, local index or global index
ColChecksumStat col_checksum_stat_;
int64_t snapshot_;
int64_t execution_id_;
int ret_code_;
int64_t table_id_;
};
class ObDDLWaitColumnChecksumCtx final
{
public:
ObDDLWaitColumnChecksumCtx();
~ObDDLWaitColumnChecksumCtx();
int init(
const int64_t task_id,
const uint64_t tenant_id,
const uint64_t source_table_id,
const uint64_t target_table_id,
const int64_t schema_version,
const int64_t snapshot_version,
const int64_t execution_id,
const int64_t timeout_us);
void reset();
bool is_inited() const { return is_inited_; }
int try_wait(bool &is_column_checksum_ready);
int update_status(const common::ObTabletID &tablet_id, const int ret_code);
TO_STRING_KV(K(is_inited_), K(source_table_id_), K(target_table_id_),
K(schema_version_), K(snapshot_version_), K(execution_id_), K(timeout_us_),
K(last_drive_ts_), K(stat_array_), K_(tenant_id));
private:
int send_calc_rpc(int64_t &send_succ_count);
int refresh_zombie_task();
private:
bool is_inited_;
uint64_t source_table_id_;
uint64_t target_table_id_;
int64_t schema_version_;
int64_t snapshot_version_;
int64_t execution_id_;
int64_t timeout_us_;
int64_t last_drive_ts_;
common::ObArray<PartitionColChecksumStat> stat_array_;
int64_t task_id_;
uint64_t tenant_id_;
common::SpinRWLock lock_;
};
} // end namespace rootserver
} // end namespace oceanbase
#endif//OCEANBASE_ROOTSERVER_OB_DDL_TASK_H_
Reference in New Issue View Git Blame Copy Permalink