/** * 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_RPC_OB_RPC_STRUCT_H_ #define OCEANBASE_RPC_OB_RPC_STRUCT_H_ #include "common/ob_member.h" #include "common/ob_member_list.h" #include "common/ob_partition_key.h" #include "common/ob_role.h" #include "common/ob_role_mgr.h" #include "common/ob_zone.h" #include "common/ob_region.h" #include "common/ob_idc.h" #include "common/ob_zone_type.h" #include "common/ob_common_types.h" #include "common/ob_unit_info.h" #include "common/ob_store_format.h" #include "share/ob_debug_sync.h" #include "share/ob_partition_modify.h" #include "share/ob_zone_info.h" #include "share/ob_server_status.h" #include "share/ob_simple_batch.h" #include "share/ob_freeze_info_proxy.h" #include "share/ob_cluster_type.h" // ObClusterType PRIMARY_CLUSTER #include "share/ob_web_service_root_addr.h" #include "share/ob_cluster_version.h" #include "share/ob_i_data_access_service.h" #include "share/ob_multi_cluster_util.h" #include "share/ob_cluster_switchover_info.h" // ObClusterSwitchoverInfoWrap #include "share/backup/ob_physical_restore_info.h" #include "share/schema/ob_error_info.h" #include "share/schema/ob_constraint.h" #include "share/schema/ob_schema_service.h" #include "share/schema/ob_udf.h" #include "share/ob_storage_format.h" #include "share/ob_replica_wrs_info.h" // ObReplicaWrsInfoList #include "share/restore/ob_restore_args.h" // ObRestoreArgs #include "rootserver/ob_rs_job_table_operator.h" #include "sql/executor/ob_task_id.h" #include "sql/parser/ob_item_type.h" // ObCacheType #include "share/partition_table/ob_partition_location_task.h" // ObPartitionBroadcastTask namespace oceanbase { namespace rootserver { class ObGlobalIndexTask; } namespace obrpc { typedef common::ObSArray ObServerList; static const int64_t MAX_COUNT = 128; static const int64_t OB_DEFAULT_ARRAY_SIZE = 8; typedef common::ObSEArray ObPkeyArray; enum ObUpgradeStage { OB_UPGRADE_STAGE_INVALID, OB_UPGRADE_STAGE_NONE, OB_UPGRADE_STAGE_PREUPGRADE, OB_UPGRADE_STAGE_DBUPGRADE, OB_UPGRADE_STAGE_POSTUPGRADE, OB_UPGRADE_STAGE_MAX }; const char* get_upgrade_stage_str(ObUpgradeStage stage); ObUpgradeStage get_upgrade_stage(const common::ObString& str); enum class MigrateMode { MT_LOCAL_FS_MODE = 0, MT_SINGLE_ZONE_MODE = 1, MT_MAX, }; enum ObCreateTableMode { OB_CREATE_TABLE_MODE_INVALID = -1, OB_CREATE_TABLE_MODE_LOOSE = 0, OB_CREATE_TABLE_MODE_STRICT = 1, OB_CREATE_TABLE_MODE_RESTORE = 2, OB_CREATE_TABLE_MODE_PHYSICAL_RESTORE = 3, // Distinguish from logical recovery OB_CREATE_TABLE_MODE_MAX, }; enum ObDefaultRoleFlag { OB_DEFUALT_NONE = 0, OB_DEFAULT_ROLE_LIST = 1, OB_DEFAULT_ROLE_ALL = 2, OB_DEFAULT_ROLE_ALL_EXCEPT = 3, OB_DEFAULT_ROLE_NONE = 4, OB_DEFAULT_ROLE_MAX, }; struct Bool { OB_UNIS_VERSION(1); public: Bool(bool v = false) : v_(v) {} operator bool() { return v_; } operator bool() const { return v_; } DEFINE_TO_STRING(BUF_PRINTO(v_)); private: bool v_; }; struct Int64 { OB_UNIS_VERSION(1); public: Int64(int64_t v = common::OB_INVALID_ID) : v_(v) {} inline void reset(); bool is_valid() const { return true; } operator int64_t() { return v_; } operator int64_t() const { return v_; } DEFINE_TO_STRING(BUF_PRINTO(v_)); private: int64_t v_; }; struct UInt64 { OB_UNIS_VERSION(1); public: UInt64(uint64_t v = common::OB_INVALID_ID) : v_(v) {} operator uint64_t() { return v_; } operator uint64_t() const { return v_; } DEFINE_TO_STRING(BUF_PRINTO(v_)); private: uint64_t v_; }; struct ObGetRootserverRoleResult { OB_UNIS_VERSION(1); public: ObGetRootserverRoleResult() : role_(0), zone_(), type_(common::REPLICA_TYPE_MAX), status_(share::status::MAX), replica_(), partition_info_() {} void reset(); DECLARE_TO_STRING; int32_t role_; common::ObZone zone_; common::ObReplicaType type_; share::status::ObRootServiceStatus status_; share::ObPartitionReplica replica_; share::ObPartitionInfo partition_info_; }; struct ObServerInfo { OB_UNIS_VERSION(1); public: common::ObZone zone_; common::ObAddr server_; common::ObRegion region_; // FIXME: () Do you need to consider region_ comparison after adding region_? I don't need to consider it for the time // being bool operator<(const ObServerInfo& r) const { return zone_ < r.zone_; } DECLARE_TO_STRING; }; struct ObPartitionId { OB_UNIS_VERSION(1); public: int64_t table_id_; int64_t partition_id_; ObPartitionId() : table_id_(common::OB_INVALID_ID), partition_id_(common::OB_INVALID_INDEX) {} DECLARE_TO_STRING; }; struct ObPartitionStat { OB_UNIS_VERSION(1); public: enum PartitionStat { RECOVERING = 0, WRITABLE = 1, }; ObPartitionStat() : partition_key_(), stat_(RECOVERING) {} void reset() { partition_key_.reset(); stat_ = RECOVERING; } common::ObPartitionKey partition_key_; PartitionStat stat_; DECLARE_TO_STRING; }; typedef common::ObSArray ObServerInfoList; typedef common::ObSArray ObPartitionList; typedef common::ObSArray ObPartitionStatList; typedef common::ObArray ObPartitionServerList; struct ObDDLArg { OB_UNIS_VERSION(1); public: ObDDLArg() : ddl_stmt_str_(), exec_tenant_id_(common::OB_INVALID_TENANT_ID), ddl_id_str_(), primary_schema_versions_(), is_replay_schema_(false), based_schema_object_infos_() {} bool is_sync_primary_query() const { return 0 < primary_schema_versions_.count(); } bool is_need_check_based_schema_objects() const { return 0 < based_schema_object_infos_.count(); } virtual bool is_allow_when_disable_ddl() const { return false; } virtual bool is_allow_when_upgrade() const { return false; } virtual int assign(const ObDDLArg& other); TO_STRING_KV( K_(ddl_stmt_str), K_(exec_tenant_id), K_(ddl_id_str), K_(is_replay_schema), K_(based_schema_object_infos)); common::ObString ddl_stmt_str_; uint64_t exec_tenant_id_; common::ObString ddl_id_str_; common::ObSEArray primary_schema_versions_; bool is_replay_schema_; common::ObSEArray based_schema_object_infos_; }; struct ObCreateResourceUnitArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateResourceUnitArg() : ObDDLArg(), min_cpu_(0), min_iops_(0), min_memory_(0), max_cpu_(0), max_memory_(0), max_disk_size_(0), max_iops_(0), max_session_num_(0), if_not_exist_(false) {} virtual ~ObCreateResourceUnitArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObCreateResourceUnitArg& other); DECLARE_TO_STRING; common::ObString unit_name_; double min_cpu_; int64_t min_iops_; int64_t min_memory_; double max_cpu_; int64_t max_memory_; int64_t max_disk_size_; int64_t max_iops_; int64_t max_session_num_; bool if_not_exist_; }; struct ObAlterResourceUnitArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObAlterResourceUnitArg() : ObDDLArg(), min_cpu_(0), min_iops_(0), min_memory_(0), max_cpu_(0), max_memory_(0), max_disk_size_(0), max_iops_(0), max_session_num_(0) {} virtual ~ObAlterResourceUnitArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObAlterResourceUnitArg& other); DECLARE_TO_STRING; common::ObString unit_name_; double min_cpu_; int64_t min_iops_; int64_t min_memory_; double max_cpu_; int64_t max_memory_; int64_t max_disk_size_; int64_t max_iops_; int64_t max_session_num_; }; struct ObDropResourceUnitArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropResourceUnitArg() : ObDDLArg(), if_exist_(false) {} virtual ~ObDropResourceUnitArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObDropResourceUnitArg& other); DECLARE_TO_STRING; common::ObString unit_name_; bool if_exist_; }; struct ObCreateResourcePoolArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateResourcePoolArg() : ObDDLArg(), unit_num_(0), if_not_exist_(0), replica_type_(common::REPLICA_TYPE_FULL), is_tenant_sys_pool_(false) {} virtual ~ObCreateResourcePoolArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObCreateResourcePoolArg& other); DECLARE_TO_STRING; common::ObString pool_name_; common::ObString unit_; int64_t unit_num_; common::ObSArray zone_list_; bool if_not_exist_; common::ObReplicaType replica_type_; bool is_tenant_sys_pool_; }; struct ObSplitResourcePoolArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObSplitResourcePoolArg() : ObDDLArg(), pool_name_(), zone_list_(), split_pool_list_() {} virtual ~ObSplitResourcePoolArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObSplitResourcePoolArg& other); TO_STRING_KV(K_(pool_name), K_(zone_list), K_(split_pool_list)); common::ObString pool_name_; common::ObSArray zone_list_; common::ObSArray split_pool_list_; }; struct ObMergeResourcePoolArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObMergeResourcePoolArg() : ObDDLArg(), old_pool_list_(), // Before the merger new_pool_list_() {} // After the merger bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObMergeResourcePoolArg& other); TO_STRING_KV(K_(old_pool_list), K_(new_pool_list)); common::ObSArray old_pool_list_; common::ObSArray new_pool_list_; }; struct ObAlterResourcePoolArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObAlterResourcePoolArg() : ObDDLArg(), pool_name_(), unit_(), unit_num_(0), zone_list_(), delete_unit_id_array_() {} virtual ~ObAlterResourcePoolArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObAlterResourcePoolArg& other); DECLARE_TO_STRING; common::ObString pool_name_; common::ObString unit_; int64_t unit_num_; common::ObSArray zone_list_; common::ObSArray delete_unit_id_array_; // This array may be empty }; struct ObDropResourcePoolArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropResourcePoolArg() : ObDDLArg(), if_exist_(false) {} virtual ~ObDropResourcePoolArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObDropResourcePoolArg& other); DECLARE_TO_STRING; common::ObString pool_name_; bool if_exist_; }; struct ObCmdArg { OB_UNIS_VERSION(1); public: common::ObString& get_sql_stmt() { return sql_text_; } const common::ObString& get_sql_stmt() const { return sql_text_; } public: common::ObString sql_text_; }; struct ObSysVarIdValue { OB_UNIS_VERSION(1); public: ObSysVarIdValue() : sys_id_(share::SYS_VAR_INVALID), value_() {} ObSysVarIdValue(share::ObSysVarClassType sys_id, common::ObString& value) : sys_id_(sys_id), value_(value) {} ~ObSysVarIdValue() {} bool is_valid() const; DECLARE_TO_STRING; share::ObSysVarClassType sys_id_; common::ObString value_; }; struct ObCreateTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateTenantArg() : ObDDLArg(), tenant_schema_(), pool_list_(), if_not_exist_(false), sys_var_list_(), name_case_mode_(common::OB_NAME_CASE_INVALID), is_restore_(false), restore_frozen_status_() {} virtual ~ObCreateTenantArg(){}; bool is_valid() const; int check_valid() const; int assign(const ObCreateTenantArg& other); DECLARE_TO_STRING; share::schema::ObTenantSchema tenant_schema_; common::ObSArray pool_list_; bool if_not_exist_; common::ObSArray sys_var_list_; common::ObNameCaseMode name_case_mode_; bool is_restore_; common::ObSArray restore_pkeys_; // For physical restore, partitions that should be created with // is_restore = REPLICA_RESTORE_DATA common::ObSArray restore_log_pkeys_; // For physical restore, partitions that should be created with // is_restore = REPLICA_RESTORE_ARCHIVE_DATA share::ObSimpleFrozenStatus restore_frozen_status_; }; struct ObCreateTenantEndArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateTenantEndArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_TENANT_ID) {} virtual ~ObCreateTenantEndArg() {} bool is_valid() const; int assign(const ObCreateTenantEndArg& other); virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; uint64_t tenant_id_; }; struct ObModifyTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum ModifiableOptions { REPLICA_NUM = 1, CHARSET_TYPE, COLLATION_TYPE, PRIMARY_ZONE, ZONE_LIST, RESOURCE_POOL_LIST, READ_ONLY, COMMENT, REWRITE_MERGE_VERSION, LOCALITY, LOGONLY_REPLICA_NUM, STORAGE_FORMAT_VERSION, STORAGE_FORMAT_WORK_VERSION, DEFAULT_TABLEGROUP, FORCE_LOCALITY, PROGRESSIVE_MERGE_NUM, MAX_OPTION, }; ObModifyTenantArg() : ObDDLArg() {} bool is_valid() const; int check_normal_tenant_can_do(bool& normal_can_do) const; virtual bool is_allow_when_disable_ddl() const; virtual bool is_allow_when_upgrade() const; DECLARE_TO_STRING; share::schema::ObTenantSchema tenant_schema_; common::ObSArray pool_list_; // used to mark alter tenant options common::ObBitSet<> alter_option_bitset_; common::ObSArray sys_var_list_; common::ObString new_tenant_name_; // for tenant rename }; struct ObLockTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObLockTenantArg() : ObDDLArg(), is_locked_(false) {} bool is_valid() const; DECLARE_TO_STRING; common::ObString tenant_name_; bool is_locked_; }; struct ObDropTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropTenantArg() : ObDDLArg(), if_exist_(false), delay_to_drop_(true), force_drop_(false), // Obsolete field open_recyclebin_(true) {} virtual ~ObDropTenantArg() {} /* * drop tenant force highest priority * At this time delay_to_drop_=false; * In other cases delay_to_drop_=true; * open_recyclebin_ is determined according to whether the recycle bin is open or not; * open_recyclebin_ open as true, enter the recycle bin * open_recyclebin_ closed to false, delayed deletion */ int assign(const ObDropTenantArg& other) { tenant_name_ = other.tenant_name_; if_exist_ = other.if_exist_; delay_to_drop_ = other.delay_to_drop_; force_drop_ = other.force_drop_; object_name_ = other.object_name_; open_recyclebin_ = other.object_name_; return common::OB_SUCCESS; } bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; common::ObString tenant_name_; bool if_exist_; bool delay_to_drop_; bool force_drop_; common::ObString object_name_; // Synchronize the name of the recycle bin in the main library bool open_recyclebin_; }; struct ObSequenceDDLArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObSequenceDDLArg() : ObDDLArg(), stmt_type_(common::OB_INVALID_ID), option_bitset_(), seq_schema_(), database_name_() {} bool is_valid() const { return !database_name_.empty(); } virtual bool is_allow_when_upgrade() const { return sql::stmt::T_DROP_SEQUENCE == stmt_type_; } void set_stmt_type(int64_t type) { stmt_type_ = type; } int64_t get_stmt_type() const { return stmt_type_; } void set_tenant_id(const uint64_t tenant_id) { seq_schema_.set_tenant_id(tenant_id); } void set_sequence_id(const uint64_t sequence_id) { seq_schema_.set_sequence_id(sequence_id); } void set_sequence_name(const common::ObString& name) { seq_schema_.set_sequence_name(name); } void set_database_name(const common::ObString& name) { database_name_ = name; } share::ObSequenceOption& option() { return seq_schema_.get_sequence_option(); } const common::ObString& get_database_name() const { return database_name_; } share::schema::ObSequenceSchema& sequence_schema() { return seq_schema_; } common::ObBitSet<>& get_option_bitset() { return option_bitset_; } const common::ObBitSet<>& get_option_bitset() const { return option_bitset_; } TO_STRING_KV(K_(stmt_type), K_(seq_schema), K_(database_name)); public: int64_t stmt_type_; common::ObBitSet<> option_bitset_; share::schema::ObSequenceSchema seq_schema_; common::ObString database_name_; }; struct ObAddSysVarArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObAddSysVarArg() : sysvar_(), if_not_exist_(false) {} DECLARE_TO_STRING; bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } share::schema::ObSysVarSchema sysvar_; bool if_not_exist_; }; struct ObModifySysVarArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObModifySysVarArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), is_inner_(false) {} DECLARE_TO_STRING; bool is_valid() const; int assign(const ObModifySysVarArg& other); virtual bool is_allow_when_upgrade() const { return true; } virtual bool is_allow_when_disable_ddl() const { return true; } uint64_t tenant_id_; common::ObSArray sys_var_list_; bool is_inner_; }; struct ObCreateDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateDatabaseArg() : ObDDLArg(), if_not_exist_(false) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; share::schema::ObDatabaseSchema database_schema_; // used to mark alter database options common::ObBitSet<> alter_option_bitset_; bool if_not_exist_; }; struct ObAlterDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum ModifiableOptions { REPLICA_NUM = 1, CHARSET_TYPE, COLLATION_TYPE, PRIMARY_ZONE, READ_ONLY, DEFAULT_TABLEGROUP, MAX_OPTION }; public: ObAlterDatabaseArg() : ObDDLArg() {} bool is_valid() const; bool only_alter_primary_zone() const { return (1 == alter_option_bitset_.num_members() && alter_option_bitset_.has_member(PRIMARY_ZONE)); } virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; share::schema::ObDatabaseSchema database_schema_; // used to mark alter database options common::ObBitSet<> alter_option_bitset_; }; struct ObDropDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropDatabaseArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), if_exist_(false), to_recyclebin_(false) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; uint64_t tenant_id_; common::ObString database_name_; bool if_exist_; bool to_recyclebin_; }; struct ObCreateTablegroupArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateTablegroupArg() : ObDDLArg(), if_not_exist_(false), create_mode_(obrpc::OB_CREATE_TABLE_MODE_STRICT) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; share::schema::ObTablegroupSchema tablegroup_schema_; bool if_not_exist_; obrpc::ObCreateTableMode create_mode_; }; struct ObDropTablegroupArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropTablegroupArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), if_exist_(false) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; uint64_t tenant_id_; common::ObString tablegroup_name_; bool if_exist_; }; struct ObTableItem; struct ObAlterTablegroupArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObAlterTablegroupArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), tablegroup_name_(), table_items_(), alter_option_bitset_(), create_mode_(OB_CREATE_TABLE_MODE_STRICT), alter_tablegroup_schema_() {} bool is_valid() const; bool is_alter_partitions() const; virtual bool is_allow_when_disable_ddl() const; virtual bool is_allow_when_upgrade() const; DECLARE_TO_STRING; enum ModifiableOptions { LOCALITY = 1, PRIMARY_ZONE, ADD_PARTITION, DROP_PARTITION, PARTITIONED_TABLE, PARTITIONED_PARTITION, REORGANIZE_PARTITION, SPLIT_PARTITION, FORCE_LOCALITY, MAX_OPTION, }; uint64_t tenant_id_; common::ObString tablegroup_name_; common::ObSArray table_items_; common::ObBitSet<> alter_option_bitset_; ObCreateTableMode create_mode_; share::schema::ObTablegroupSchema alter_tablegroup_schema_; }; struct ObReachPartitionLimitArg { OB_UNIS_VERSION(1); public: ObReachPartitionLimitArg() : batch_cnt_(0), tenant_id_(common::OB_INVALID_ID), is_pg_arg_(false) {} ObReachPartitionLimitArg(const int64_t batch_cnt, const uint64_t tenant_id, const bool is_pg_arg) : batch_cnt_(batch_cnt), tenant_id_(tenant_id), is_pg_arg_(is_pg_arg) {} virtual ~ObReachPartitionLimitArg() {} bool is_valid() const; TO_STRING_KV(K_(batch_cnt), K_(tenant_id), K_(is_pg_arg)); public: int64_t batch_cnt_; uint64_t tenant_id_; bool is_pg_arg_; }; struct ObCheckFrozenVersionArg { OB_UNIS_VERSION(1); public: ObCheckFrozenVersionArg() : frozen_version_(0) {} virtual ~ObCheckFrozenVersionArg() {} bool is_valid() const { return frozen_version_ > 0; } TO_STRING_KV(K_(frozen_version)); public: int64_t frozen_version_; }; struct ObGetMinSSTableSchemaVersionArg { OB_UNIS_VERSION(1); public: ObGetMinSSTableSchemaVersionArg() { tenant_id_arg_list_.reuse(); } virtual ~ObGetMinSSTableSchemaVersionArg() { tenant_id_arg_list_.reset(); } bool is_valid() const { return tenant_id_arg_list_.size() > 0; } TO_STRING_KV(K_(tenant_id_arg_list)); public: common::ObSArray tenant_id_arg_list_; }; struct ObCreateIndexArg; // Forward declaration struct ObCreateForeignKeyArg; // Forward declaration struct ObCreateTableArg : ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateTableArg() : ObDDLArg(), if_not_exist_(false), create_mode_(OB_CREATE_TABLE_MODE_STRICT), last_replay_log_id_(0), is_inner_(false), error_info_() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const; DECLARE_TO_STRING; bool if_not_exist_; share::schema::ObTableSchema schema_; common::ObSArray index_arg_list_; common::ObSArray foreign_key_arg_list_; common::ObSEArray constraint_list_; common::ObString db_name_; ObCreateTableMode create_mode_; uint64_t last_replay_log_id_; bool is_inner_; share::schema::ObErrorInfo error_info_; // New members of ObCreateTableArg need to pay attention to the implementation of is_allow_when_upgrade }; struct ObCreateTableLikeArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateTableLikeArg() : ObDDLArg(), if_not_exist_(false), tenant_id_(common::OB_INVALID_ID), table_type_(share::schema::USER_TABLE), origin_db_name_(), origin_table_name_(), new_db_name_(), new_table_name_(), create_host_(), create_mode_(OB_CREATE_TABLE_MODE_STRICT) {} bool is_valid() const; DECLARE_TO_STRING; bool if_not_exist_; uint64_t tenant_id_; share::schema::ObTableType table_type_; common::ObString origin_db_name_; common::ObString origin_table_name_; common::ObString new_db_name_; common::ObString new_table_name_; common::ObString create_host_; // Temporary table is valid ObCreateTableMode create_mode_; }; struct ObCreateSynonymArg : ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateSynonymArg() : or_replace_(false), synonym_info_(), db_name_() {} TO_STRING_KV(K_(synonym_info), K_(db_name), K_(obj_db_name)); bool or_replace_; share::schema::ObSynonymInfo synonym_info_; common::ObString db_name_; common::ObString obj_db_name_; }; struct ObDropSynonymArg : ObDDLArg { OB_UNIS_VERSION(1); public: ObDropSynonymArg() : tenant_id_(common::OB_INVALID_ID), is_force_(false), db_name_(), synonym_name_() {} virtual ~ObDropSynonymArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(is_force), K_(db_name), K_(synonym_name)); uint64_t tenant_id_; bool is_force_; common::ObString db_name_; common::ObString synonym_name_; }; struct ObAlterPlanBaselineArg : ObDDLArg { OB_UNIS_VERSION(1); public: enum FieldUpdated { FIXED = 0x1, ENABLED = 0x02, OUTLINE_DATA = 0x4, }; ObAlterPlanBaselineArg() : plan_baseline_info_(), field_update_bitmap_(0) {} TO_STRING_KV(K_(plan_baseline_info), K_(field_update_bitmap)); share::schema::ObPlanBaselineInfo plan_baseline_info_; uint64_t field_update_bitmap_; void restore(const share::schema::ObPlanBaselineInfo& old); }; struct ObCreatePlanBaselineArg : ObDDLArg { OB_UNIS_VERSION(1); public: ObCreatePlanBaselineArg() : plan_baseline_info_(), is_replace_(false) {} TO_STRING_KV(K_(plan_baseline_info), K(is_replace_)); share::schema::ObPlanBaselineInfo plan_baseline_info_; bool is_replace_; }; struct ObDropPlanBaselineArg : ObDDLArg { OB_UNIS_VERSION(1); public: ObDropPlanBaselineArg() : tenant_id_(common::OB_INVALID_ID), sql_id_(), plan_hash_value_(common::OB_INVALID_ID), plan_baseline_id_(common::OB_INVALID_ID), db_name_() {} virtual ~ObDropPlanBaselineArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(sql_id), K_(plan_hash_value)); uint64_t tenant_id_; common::ObString sql_id_; uint64_t plan_hash_value_; uint64_t plan_baseline_id_; common::ObString db_name_; }; struct ObIndexArg : public ObDDLArg { OB_UNIS_VERSION_V(1); public: enum IndexActionType { INVALID_ACTION = 1, ADD_INDEX, DROP_INDEX, ALTER_INDEX, DROP_FOREIGN_KEY, // The foreign key is a 1.4 function, and rename_index needs to be placed at the back in // consideration of compatibility RENAME_INDEX, ALTER_INDEX_PARALLEL, REBUILD_INDEX }; uint64_t tenant_id_; uint64_t session_id_; // The session id is passed in when building the index, and the table schema is searched by rs // according to the temporary table and then the ordinary table. common::ObString index_name_; common::ObString table_name_; common::ObString database_name_; IndexActionType index_action_type_; ObIndexArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), session_id_(common::OB_INVALID_ID), index_name_(), table_name_(), database_name_(), index_action_type_(INVALID_ACTION) {} virtual ~ObIndexArg() {} void reset() { tenant_id_ = common::OB_INVALID_ID; session_id_ = common::OB_INVALID_ID; index_name_.reset(); table_name_.reset(); database_name_.reset(); index_action_type_ = INVALID_ACTION; } bool is_valid() const; virtual bool is_allow_when_upgrade() const; int assign(const ObIndexArg& other) { tenant_id_ = other.tenant_id_; session_id_ = other.session_id_; index_name_ = other.index_name_; table_name_ = other.table_name_; database_name_ = other.database_name_; index_action_type_ = other.index_action_type_; return common::OB_SUCCESS; } DECLARE_VIRTUAL_TO_STRING; }; struct ObUpdateStatCacheArg : public ObDDLArg { OB_UNIS_VERSION_V(1); public: ObUpdateStatCacheArg() : tenant_id_(common::OB_INVALID_ID), table_id_(common::OB_INVALID_ID), partition_ids_(), column_ids_() {} virtual ~ObUpdateStatCacheArg() {} void rest() { tenant_id_ = common::OB_INVALID_ID, table_id_ = common::OB_INVALID_ID, partition_ids_.reset(); column_ids_.reset(); } bool is_valid() const; int assign(const ObUpdateStatCacheArg& other) { int ret = common::OB_SUCCESS; tenant_id_ = other.tenant_id_; table_id_ = other.table_id_; if (OB_FAIL(ObDDLArg::assign(other))) { SHARE_LOG(WARN, "fail to assign ddl arg", KR(ret)); } else if (OB_FAIL(partition_ids_.assign(other.partition_ids_))) { SHARE_LOG(WARN, "fail to assign partition ids", KR(ret)); } else if (OB_FAIL(column_ids_.assign(other.column_ids_))) { SHARE_LOG(WARN, "fail to assign column ids", KR(ret)); } else { /*do nothing*/ } return ret; } virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; uint64_t table_id_; common::ObSArray partition_ids_; common::ObSArray column_ids_; DECLARE_VIRTUAL_TO_STRING; }; struct ObDropIndexArg : public ObIndexArg { OB_UNIS_VERSION(1); // if add new member,should add to_string and serialize function public: ObDropIndexArg() { index_action_type_ = DROP_INDEX; to_recyclebin_ = false; index_table_id_ = common::OB_INVALID_ID; } virtual ~ObDropIndexArg() {} void reset() { ObIndexArg::reset(); index_action_type_ = DROP_INDEX; } bool is_valid() const { return ObIndexArg::is_valid(); } bool to_recyclebin() const { return to_recyclebin_; } bool to_recyclebin_; uint64_t index_table_id_; DECLARE_VIRTUAL_TO_STRING; }; struct ObRebuildIndexArg : public ObIndexArg { OB_UNIS_VERSION(1); // if add new member,should add to_string and serialize function public: ObRebuildIndexArg() : ObIndexArg() { create_mode_ = OB_CREATE_TABLE_MODE_STRICT; index_action_type_ = REBUILD_INDEX; index_table_id_ = common::OB_INVALID_ID; } virtual ~ObRebuildIndexArg() {} int assign(const ObRebuildIndexArg& other) { int ret = common::OB_SUCCESS; if (OB_FAIL(ObIndexArg::assign(other))) { SHARE_LOG(WARN, "fail to assign base", K(ret)); } else { create_mode_ = other.create_mode_; index_table_id_ = other.index_table_id_; } return ret; } void reset() { ObIndexArg::reset(); index_action_type_ = REBUILD_INDEX; } bool is_valid() const { return ObIndexArg::is_valid(); } ObCreateTableMode create_mode_; uint64_t index_table_id_; DECLARE_VIRTUAL_TO_STRING; }; struct ObAlterIndexParallelArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObAlterIndexParallelArg() : ObIndexArg(), new_parallel_(common::OB_DEFAULT_TABLE_DOP) { index_action_type_ = ALTER_INDEX_PARALLEL; } virtual ~ObAlterIndexParallelArg() {} void reset() { ObIndexArg::reset(); index_action_type_ = ALTER_INDEX_PARALLEL; new_parallel_ = common::OB_DEFAULT_TABLE_DOP; } bool is_valid() const { // parallel must be greater than 0 return new_parallel_ > 0; } int64_t new_parallel_; DECLARE_VIRTUAL_TO_STRING; }; struct ObRenameIndexArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObRenameIndexArg() : ObIndexArg(), origin_index_name_(), new_index_name_() { index_action_type_ = RENAME_INDEX; } virtual ~ObRenameIndexArg() {} void reset() { ObIndexArg::reset(); index_action_type_ = RENAME_INDEX; origin_index_name_.reset(); new_index_name_.reset(); } bool is_valid() const; common::ObString origin_index_name_; common::ObString new_index_name_; DECLARE_VIRTUAL_TO_STRING; }; struct ObAlterIndexArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObAlterIndexArg() : ObIndexArg(), index_visibility_(common::OB_DEFAULT_INDEX_VISIBILITY) { index_action_type_ = ALTER_INDEX; } virtual ~ObAlterIndexArg() {} void reset() { ObIndexArg::reset(); index_action_type_ = ALTER_INDEX; index_visibility_ = common::OB_DEFAULT_INDEX_VISIBILITY; } bool is_valid() const; uint64_t index_visibility_; DECLARE_VIRTUAL_TO_STRING; }; struct ObTruncateTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObTruncateTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), session_id_(common::OB_INVALID_ID), database_name_(), table_name_(), create_mode_(OB_CREATE_TABLE_MODE_STRICT), to_recyclebin_(false) {} bool is_valid() const; DECLARE_TO_STRING; uint64_t tenant_id_; uint64_t session_id_; // Pass in session id when truncate table common::ObString database_name_; common::ObString table_name_; ObCreateTableMode create_mode_; bool to_recyclebin_; }; struct ObRenameTableItem { OB_UNIS_VERSION(1); public: ObRenameTableItem() : origin_db_name_(), new_db_name_(), origin_table_name_(), new_table_name_(), origin_table_id_(common::OB_INVALID_ID) {} bool is_valid() const; DECLARE_TO_STRING; common::ObString origin_db_name_; common::ObString new_db_name_; common::ObString origin_table_name_; common::ObString new_table_name_; uint64_t origin_table_id_; // only used in work thread, no need add to SERIALIZE now }; struct ObRenameTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRenameTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), rename_table_items_() {} bool is_valid() const; DECLARE_TO_STRING; uint64_t tenant_id_; common::ObSArray rename_table_items_; }; struct ObAlterTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum ModifiableTableColumns { AUTO_INCREMENT = 1, BLOCK_SIZE, CHARSET_TYPE, COLLATION_TYPE, COMPRESS_METHOD, COMMENT, EXPIRE_INFO, PRIMARY_ZONE, REPLICA_NUM, TABLET_SIZE, PCTFREE, PROGRESSIVE_MERGE_NUM, TABLE_NAME, TABLEGROUP_NAME, SEQUENCE_COLUMN_ID, USE_BLOOM_FILTER, READ_ONLY, LOCALITY, SESSION_ID, SESSION_ACTIVE_TIME, STORE_FORMAT, DUPLICATE_SCOPE, ENABLE_ROW_MOVEMENT, PROGRESSIVE_MERGE_ROUND, STORAGE_FORMAT_VERSION, FORCE_LOCALITY, TABLE_MODE, TABLE_DOP, MAX_OPTION = 1000 }; enum AlterPartitionType { ADD_PARTITION = -1, DROP_PARTITION, PARTITIONED_TABLE, PARTITIONED_PARTITION, REORGANIZE_PARTITION, SPLIT_PARTITION, TRUNCATE_PARTITION, ADD_SUB_PARTITION, DROP_SUB_PARTITION, TRUNCATE_SUB_PARTITION, NO_OPERATION = 1000 }; enum AlterConstraintType { ADD_CONSTRAINT = -1, DROP_CONSTRAINT, ALTER_CONSTRAINT_STATE, CONSTRAINT_NO_OPERATION = 1000 }; ObAlterTableArg() : is_alter_columns_(false), is_alter_indexs_(false), is_alter_options_(false), is_alter_partitions_(false), session_id_(common::OB_INVALID_ID), alter_part_type_(NO_OPERATION), alter_constraint_type_(CONSTRAINT_NO_OPERATION), index_arg_list_(), foreign_key_arg_list_(), alter_table_schema_(), // To be precise, this should be called create_partition_mode? create_mode_(OB_CREATE_TABLE_MODE_STRICT), tz_info_wrap_(), is_inner_(false), nls_formats_{}, skip_sys_table_check_(false), is_update_global_indexes_(false) {} ~ObAlterTableArg() { for (int64_t i = 0; i < index_arg_list_.size(); ++i) { ObIndexArg* index_arg = index_arg_list_.at(i); if (OB_NOT_NULL(index_arg)) { index_arg->~ObIndexArg(); } } allocator_.clear(); } bool is_valid() const; bool has_rename_action() const { return alter_table_schema_.alter_option_bitset_.has_member(TABLE_NAME); } bool need_progressive_merge() const { return alter_table_schema_.alter_option_bitset_.has_member(BLOCK_SIZE) || alter_table_schema_.alter_option_bitset_.has_member(COMPRESS_METHOD) || alter_table_schema_.alter_option_bitset_.has_member(PCTFREE) || alter_table_schema_.alter_option_bitset_.has_member(STORE_FORMAT) || alter_table_schema_.alter_option_bitset_.has_member(STORAGE_FORMAT_VERSION) || alter_table_schema_.alter_option_bitset_.has_member(PROGRESSIVE_MERGE_ROUND); } virtual bool is_allow_when_disable_ddl() const; virtual bool is_allow_when_upgrade() const; bool is_refresh_sess_active_time() const; inline void set_tz_info_map(const common::ObTZInfoMap* tz_info_map) { tz_info_wrap_.set_tz_info_map(tz_info_map); tz_info_.set_tz_info_map(tz_info_map); } int set_nls_formats(const common::ObString* nls_formats); TO_STRING_KV(K_(is_alter_columns), K_(is_alter_indexs), K_(is_alter_options), K_(session_id), K_(index_arg_list), K_(alter_table_schema), K_(is_inner), "nls_formats", common::ObArrayWrap(nls_formats_, common::ObNLSFormatEnum::NLS_MAX)); bool is_alter_columns_; bool is_alter_indexs_; bool is_alter_options_; bool is_alter_partitions_; uint64_t session_id_; // Only used to update the last active time of the temporary table. At this time, the session // id used to create the temporary table is passed in AlterPartitionType alter_part_type_; AlterConstraintType alter_constraint_type_; common::ObSArray index_arg_list_; common::ObSArray foreign_key_arg_list_; share::schema::AlterTableSchema alter_table_schema_; common::ObArenaAllocator allocator_; common::ObTimeZoneInfo tz_info_; // unused now ObCreateTableMode create_mode_; common::ObTimeZoneInfoWrap tz_info_wrap_; bool is_inner_; common::ObString nls_formats_[common::ObNLSFormatEnum::NLS_MAX]; bool skip_sys_table_check_; bool is_update_global_indexes_; int serialize_index_args(char* buf, const int64_t data_len, int64_t& pos) const; int deserialize_index_args(const char* buf, const int64_t data_len, int64_t& pos); int64_t get_index_args_serialize_size() const; }; struct ObTableItem { OB_UNIS_VERSION(1); public: ObTableItem() : mode_(common::OB_NAME_CASE_INVALID), // for compare database_name_(), table_name_() {} bool operator==(const ObTableItem& table_item) const; inline uint64_t hash(uint64_t seed = 0) const; void reset() { mode_ = common::OB_NAME_CASE_INVALID; database_name_.reset(); table_name_.reset(); } DECLARE_TO_STRING; common::ObNameCaseMode mode_; common::ObString database_name_; common::ObString table_name_; }; inline uint64_t ObTableItem::hash(uint64_t seed) const { uint64_t val = seed; if (!database_name_.empty() && !table_name_.empty()) { val = common::murmurhash(database_name_.ptr(), database_name_.length(), val); val = common::murmurhash(table_name_.ptr(), table_name_.length(), val); } return val; } struct ObDropTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), session_id_(common::OB_INVALID_ID), sess_create_time_(0), table_type_(share::schema::MAX_TABLE_TYPE), tables_(), if_exist_(false), to_recyclebin_(false) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; uint64_t tenant_id_; uint64_t session_id_; // Pass in session id when deleting table int64_t sess_create_time_; // When deleting oracle temporary table data, pass in the creation time of sess share::schema::ObTableType table_type_; common::ObSArray tables_; bool if_exist_; bool to_recyclebin_; }; struct ObOptimizeTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObOptimizeTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), tables_() {} DECLARE_TO_STRING; bool is_valid() const; uint64_t tenant_id_; common::ObSArray tables_; }; struct ObOptimizeTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObOptimizeTenantArg() : ObDDLArg(), tenant_name_() {} bool is_valid() const; DECLARE_TO_STRING; common::ObString tenant_name_; }; struct ObOptimizeAllArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObOptimizeAllArg() : ObDDLArg() {} bool is_valid() const { return true; } DECLARE_TO_STRING; }; struct ObColumnSortItem { OB_UNIS_VERSION(1); public: ObColumnSortItem() : column_name_(), prefix_len_(0), order_type_(common::ObOrderType::ASC), column_id_(common::OB_INVALID_ID), is_func_index_(false) {} void reset() { column_name_.reset(); prefix_len_ = 0; order_type_ = common::ObOrderType::ASC; column_id_ = common::OB_INVALID_ID; is_func_index_ = false; } inline uint64_t get_column_id() const { return column_id_; } DECLARE_TO_STRING; common::ObString column_name_; int32_t prefix_len_; common::ObOrderType order_type_; uint64_t column_id_; bool is_func_index_; // Whether the mark is a function index, the default is false. }; struct ObTableOption { OB_UNIS_VERSION_V(1); public: ObTableOption() : block_size_(-1), replica_num_(0), index_status_(share::schema::INDEX_STATUS_UNAVAILABLE), use_bloom_filter_(false), compress_method_("none"), comment_(), progressive_merge_num_(common::OB_DEFAULT_PROGRESSIVE_MERGE_NUM), primary_zone_(), row_store_type_(common::MAX_ROW_STORE), store_format_(common::OB_STORE_FORMAT_INVALID), progressive_merge_round_(0), storage_format_version_(common::OB_STORAGE_FORMAT_VERSION_INVALID) {} virtual void reset() { block_size_ = common::OB_DEFAULT_SSTABLE_BLOCK_SIZE; replica_num_ = -1; index_status_ = share::schema::INDEX_STATUS_UNAVAILABLE; use_bloom_filter_ = false; compress_method_ = common::ObString::make_string("none"); comment_.reset(); tablegroup_name_.reset(); progressive_merge_num_ = common::OB_DEFAULT_PROGRESSIVE_MERGE_NUM; primary_zone_.reset(); row_store_type_ = common::MAX_ROW_STORE; store_format_ = common::OB_STORE_FORMAT_INVALID; progressive_merge_round_ = 0; storage_format_version_ = common::OB_STORAGE_FORMAT_VERSION_INVALID; } bool is_valid() const; DECLARE_TO_STRING; int64_t block_size_; int64_t replica_num_; share::schema::ObIndexStatus index_status_; bool use_bloom_filter_; common::ObString compress_method_; common::ObString comment_; common::ObString tablegroup_name_; int64_t progressive_merge_num_; common::ObString primary_zone_; common::ObRowStoreType row_store_type_; common::ObStoreFormatType store_format_; int64_t progressive_merge_round_; int64_t storage_format_version_; }; struct ObIndexOption : public ObTableOption { OB_UNIS_VERSION(1); public: ObIndexOption() : ObTableOption(), parser_name_(common::OB_DEFAULT_FULLTEXT_PARSER_NAME), index_attributes_set_(common::OB_DEFAULT_INDEX_ATTRIBUTES_SET) {} bool is_valid() const; void reset() { ObTableOption::reset(); parser_name_ = common::ObString::make_string(common::OB_DEFAULT_FULLTEXT_PARSER_NAME); } DECLARE_TO_STRING; common::ObString parser_name_; uint64_t index_attributes_set_; // flags, one bit for one attribute }; struct ObCreateIndexArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObCreateIndexArg() : index_type_(share::schema::INDEX_TYPE_IS_NOT), index_columns_(), store_columns_(), hidden_store_columns_(), fulltext_columns_(), index_option_(), create_mode_(OB_CREATE_TABLE_MODE_STRICT), data_table_id_(common::OB_INVALID_ID), index_table_id_(common::OB_INVALID_ID), if_not_exist_(false), with_rowid_(false), index_schema_(), is_inner_(false), nls_date_format_(), nls_timestamp_format_(), nls_timestamp_tz_format_(), sql_mode_(0) { index_action_type_ = ADD_INDEX; index_using_type_ = share::schema::USING_BTREE; } virtual ~ObCreateIndexArg() {} void reset() { ObIndexArg::reset(); index_action_type_ = ADD_INDEX; index_type_ = share::schema::INDEX_TYPE_IS_NOT; index_columns_.reset(); store_columns_.reset(); hidden_store_columns_.reset(); fulltext_columns_.reset(); index_option_.reset(); index_using_type_ = share::schema::USING_BTREE; data_table_id_ = common::OB_INVALID_ID; index_table_id_ = common::OB_INVALID_ID; if_not_exist_ = false; with_rowid_ = false; index_schema_.reset(); is_inner_ = false; nls_date_format_.reset(); nls_timestamp_format_.reset(); nls_timestamp_tz_format_.reset(); sql_mode_ = 0; } bool is_valid() const; int assign(const ObCreateIndexArg& other) { int ret = common::OB_SUCCESS; if (OB_FAIL(ObIndexArg::assign(other))) { SHARE_LOG(WARN, "fail to assign base", K(ret)); } else if (OB_FAIL(index_columns_.assign(other.index_columns_))) { SHARE_LOG(WARN, "fail to assign index columns", K(ret)); } else if (OB_FAIL(store_columns_.assign(other.store_columns_))) { SHARE_LOG(WARN, "fail to assign store columns", K(ret)); } else if (OB_FAIL(hidden_store_columns_.assign(other.hidden_store_columns_))) { SHARE_LOG(WARN, "fail to assign hidden store columns", K(ret)); } else if (OB_FAIL(fulltext_columns_.assign(other.fulltext_columns_))) { SHARE_LOG(WARN, "fail to assign fulltext columns", K(ret)); } else if (OB_FAIL(index_schema_.assign(other.index_schema_))) { SHARE_LOG(WARN, "fail to assign index schema", K(ret)); } else { index_type_ = other.index_type_; index_option_ = other.index_option_; index_using_type_ = other.index_using_type_; create_mode_ = other.create_mode_; data_table_id_ = other.data_table_id_; index_table_id_ = other.index_table_id_; if_not_exist_ = other.if_not_exist_; with_rowid_ = other.with_rowid_; is_inner_ = other.is_inner_; nls_date_format_ = other.nls_date_format_; nls_timestamp_format_ = other.nls_timestamp_format_; nls_timestamp_tz_format_ = other.nls_timestamp_tz_format_; sql_mode_ = other.sql_mode_; } return ret; } inline bool is_unique_primary_index() const { return share::schema::INDEX_TYPE_UNIQUE_LOCAL == index_type_ || share::schema::INDEX_TYPE_UNIQUE_GLOBAL == index_type_ || share::schema::INDEX_TYPE_UNIQUE_GLOBAL_LOCAL_STORAGE == index_type_ || share::schema::INDEX_TYPE_PRIMARY == index_type_; } DECLARE_VIRTUAL_TO_STRING; share::schema::ObIndexType index_type_; common::ObSEArray index_columns_; common::ObSEArray store_columns_; common::ObSEArray hidden_store_columns_; common::ObSEArray fulltext_columns_; ObIndexOption index_option_; share::schema::ObIndexUsingType index_using_type_; ObCreateTableMode create_mode_; uint64_t data_table_id_; uint64_t index_table_id_; // Data_table_id and index_table_id will be given in SQL during recovery bool if_not_exist_; bool with_rowid_; share::schema::ObTableSchema index_schema_; // Index table schema bool is_inner_; // Nls_xx_format is required when creating a functional index common::ObString nls_date_format_; common::ObString nls_timestamp_format_; common::ObString nls_timestamp_tz_format_; ObSQLMode sql_mode_; }; struct ObCreateForeignKeyArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObCreateForeignKeyArg() : ObIndexArg(), parent_database_(), parent_table_(), child_columns_(), parent_columns_(), update_action_(share::schema::ACTION_INVALID), delete_action_(share::schema::ACTION_INVALID), foreign_key_name_(), enable_flag_(true), is_modify_enable_flag_(false), ref_cst_type_(), ref_cst_id_(), validate_flag_(true), is_modify_validate_flag_(false), rely_flag_(false), is_modify_rely_flag_(false), is_modify_fk_state_(false) {} virtual ~ObCreateForeignKeyArg() {} void reset() { ObIndexArg::reset(); parent_database_.reset(); parent_table_.reset(); child_columns_.reset(); parent_columns_.reset(); update_action_ = share::schema::ACTION_INVALID; delete_action_ = share::schema::ACTION_INVALID; foreign_key_name_.reset(); enable_flag_ = true; is_modify_enable_flag_ = false; ref_cst_type_ = share::schema::CONSTRAINT_TYPE_INVALID; ref_cst_id_ = common::OB_INVALID_ID; validate_flag_ = true; is_modify_validate_flag_ = false; rely_flag_ = false; is_modify_rely_flag_ = false; is_modify_fk_state_ = false; } bool is_valid() const; DECLARE_VIRTUAL_TO_STRING; public: common::ObString parent_database_; common::ObString parent_table_; common::ObSEArray child_columns_; common::ObSEArray parent_columns_; share::schema::ObReferenceAction update_action_; share::schema::ObReferenceAction delete_action_; common::ObString foreign_key_name_; bool enable_flag_; bool is_modify_enable_flag_; share::schema::ObConstraintType ref_cst_type_; uint64_t ref_cst_id_; bool validate_flag_; bool is_modify_validate_flag_; bool rely_flag_; bool is_modify_rely_flag_; bool is_modify_fk_state_; }; struct ObDropForeignKeyArg : public ObIndexArg { OB_UNIS_VERSION_V(1); public: ObDropForeignKeyArg() : ObIndexArg(), foreign_key_name_() { index_action_type_ = DROP_FOREIGN_KEY; } virtual ~ObDropForeignKeyArg() {} void reset() { ObIndexArg::reset(); foreign_key_name_.reset(); } bool is_valid() const; DECLARE_VIRTUAL_TO_STRING; public: common::ObString foreign_key_name_; }; struct ObFlashBackTableFromRecyclebinArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFlashBackTableFromRecyclebinArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), origin_db_name_(), origin_table_name_(), new_db_name_(), new_table_name_(), origin_table_id_(common::OB_INVALID_ID) {} bool is_valid() const; uint64_t tenant_id_; common::ObString origin_db_name_; common::ObString origin_table_name_; common::ObString new_db_name_; common::ObString new_table_name_; uint64_t origin_table_id_; // only used in work thread, no need add to SERIALIZE now TO_STRING_KV(K_(tenant_id), K_(origin_db_name), K_(origin_table_name), K_(new_db_name), K_(new_table_name), K_(origin_table_id)); }; struct ObFlashBackIndexArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFlashBackIndexArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), origin_table_name_(), new_db_name_(), new_table_name_(), origin_table_id_(common::OB_INVALID_ID) {} bool is_valid() const; uint64_t tenant_id_; common::ObString origin_table_name_; common::ObString new_db_name_; common::ObString new_table_name_; uint64_t origin_table_id_; // only used in work thread, no need add to SERIALIZE now TO_STRING_KV(K_(tenant_id), K_(origin_table_name), K_(new_db_name), K_(new_table_name), K_(origin_table_id)); }; struct ObFlashBackDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFlashBackDatabaseArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), origin_db_name_(), new_db_name_() {} bool is_valid() const; uint64_t tenant_id_; common::ObString origin_db_name_; common::ObString new_db_name_; TO_STRING_KV(K_(tenant_id), K_(origin_db_name), K_(new_db_name)); }; struct ObFlashBackTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFlashBackTenantArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), origin_tenant_name_(), new_tenant_name_() {} bool is_valid() const; uint64_t tenant_id_; common::ObString origin_tenant_name_; common::ObString new_tenant_name_; TO_STRING_KV(K_(tenant_id), K_(origin_tenant_name), K_(new_tenant_name)); }; struct ObPurgeTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObPurgeTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), table_name_() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; common::ObString table_name_; TO_STRING_KV(K_(tenant_id), K_(table_name)); }; struct ObPurgeIndexArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObPurgeIndexArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), table_name_(), table_id_(common::OB_INVALID_ID) {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; common::ObString table_name_; uint64_t table_id_; // only used in work thread, no need add to SERIALIZE now TO_STRING_KV(K_(tenant_id), K_(table_name), K_(table_id)); }; struct ObPurgeDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObPurgeDatabaseArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), db_name_() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; common::ObString db_name_; TO_STRING_KV(K_(tenant_id), K_(db_name)); }; struct ObPurgeTenantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObPurgeTenantArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), tenant_name_() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; common::ObString tenant_name_; TO_STRING_KV(K_(tenant_id), K_(tenant_name)); }; struct ObPurgeRecycleBinArg : public ObDDLArg { OB_UNIS_VERSION(1); public: static const int DEFAULT_PURGE_EACH_TIME = 10; ObPurgeRecycleBinArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), purge_num_(0), expire_time_(0), auto_purge_(false) {} virtual ~ObPurgeRecycleBinArg() {} bool is_valid() const; int assign(const ObPurgeRecycleBinArg& other); virtual bool is_allow_when_upgrade() const { return true; } uint64_t tenant_id_; int64_t purge_num_; int64_t expire_time_; bool auto_purge_; TO_STRING_KV(K_(tenant_id), K_(purge_num), K_(expire_time), K_(auto_purge)); }; /* * 1. When pg_key_ and partition_key_ are equal, the entity partition needs to be created. * 1.1 When both partition_key and pg_key are filled in as the partition key of a table, * the physical partition of the standalone table is created * 1.2 When partition_key and pg_key are both filled in as a tg pg_key, a pg physical partition is created * 1.3 In both cases 1.1 and 1.2, the entity partition is created, and the is_binding() method is false * 2. When pg_key_ and partition_key_ are not equal, there is no need to create an entity partition * 2.1 At this time, the partition partition of a table is bound to a physical partition of pg * 2.2 In the case of 2.1, the partition of the table is helped by the physical partition of the pg, * and the is_binding() method returns true */ struct ObCreatePartitionArg { OB_UNIS_VERSION(1); public: ObCreatePartitionArg() { reset(); } ~ObCreatePartitionArg() {} inline void reset(); bool is_valid() const; bool is_binding() const { return pg_key_ != partition_key_; } int check_need_create_sstable(bool& need_create_sstable) const; int set_memstore_percent(const int64_t mp) { return replica_property_.set_memstore_percent(mp); } int64_t get_memstore_percent() const { return replica_property_.get_memstore_percent(); } // Meaning of pg_key_ / partition_key_ value: // (1) partition/partition -> craete_partition // (2) pg / partition -> add partition to pg // (3) pg / pg -> create pg bool is_create_pg() const { return pg_key_.is_pg() && pg_key_.is_valid() && pg_key_ == partition_key_; } bool is_create_pg_partition() const { return pg_key_.is_pg() && pg_key_.is_valid() && partition_key_.is_valid() && pg_key_ != partition_key_; } bool is_standby_restore() const { return share::REPLICA_RESTORE_STANDBY == restore_; } int deep_copy(const ObCreatePartitionArg& arg); int assign(const ObCreatePartitionArg& other); DECLARE_TO_STRING; common::ObZone zone_; common::ObPartitionKey partition_key_; int64_t schema_version_; int64_t memstore_version_; int64_t replica_num_; // The number of versatile copies common::ObMemberList member_list_; common::ObAddr leader_; int64_t lease_start_; int64_t logonly_replica_num_; // Number of journal copies int64_t backup_replica_num_; // Number of backup copies int64_t readonly_replica_num_; // Number of read-only replicas common::ObReplicaType replica_type_; // Copy type int64_t last_submit_timestamp_; // next log id timestamp int64_t restore_; // If it is not 0, it means that it needs to be restored common::ObSArray table_schemas_; common::ObPartitionKey source_partition_key_; // It makes sense when dismantling tables and splitting to build // partiton (obsolete) int64_t frozen_timestamp_; // It is a pair with memstore_version, indicating the snapshot corresponding to the // version; int64_t non_paxos_replica_num_; uint64_t last_replay_log_id_; // Only used for force_create_sys_table, the default value is 0 common::ObPGKey pg_key_; common::ObReplicaProperty replica_property_; share::ObSplitPartition split_info_; // It makes sense when dismantling tables and splitting to build partiton bool ignore_member_list_; // Used to mark whether the partition needs to be created repeatedly, currently only used // in the creation of replicas synchronized from the standby database private: DISALLOW_COPY_AND_ASSIGN(ObCreatePartitionArg); }; struct ObCreatePartitionStorageArg { OB_UNIS_VERSION(1); public: ObCreatePartitionStorageArg() { reset(); } ~ObCreatePartitionStorageArg() {} inline void reset(); bool is_valid() const; DECLARE_TO_STRING; common::ObPGKey rgkey_; common::ObPartitionKey partition_key_; int64_t schema_version_; int64_t memstore_version_; int64_t last_submit_timestamp_; // next log id timestamp int64_t restore_; // If it is not 0, it means that it needs to be restored common::ObSArray table_schemas_; }; struct ObCreatePartitionBatchArg { OB_UNIS_VERSION(1); public: ObCreatePartitionBatchArg() { reset(); } ~ObCreatePartitionBatchArg() {} bool is_valid() const; inline void reset(); int assign(const ObCreatePartitionBatchArg& other); void reuse() { args_.reuse(); } DECLARE_TO_STRING; common::ObSArray args_; private: DISALLOW_COPY_AND_ASSIGN(ObCreatePartitionBatchArg); }; struct ObSetMemberListArg { OB_UNIS_VERSION(1); public: ObSetMemberListArg() : key_(), member_list_(), quorum_(0), lease_start_(0), leader_() {} ~ObSetMemberListArg() {} bool is_valid() const; void reset(); int assign(const ObSetMemberListArg& other); int init(const int64_t table_id, const int64_t partition_id, const int64_t partition_cnt, const common::ObMemberList& member_list, const int64_t quorum, const int64_t lease_start = 0, const common::ObAddr& leader = common::ObAddr()); DECLARE_TO_STRING; common::ObPartitionKey key_; common::ObMemberList member_list_; int64_t quorum_; int64_t lease_start_; common::ObAddr leader_; private: DISALLOW_COPY_AND_ASSIGN(ObSetMemberListArg); }; struct ObSetMemberListBatchArg { OB_UNIS_VERSION(1); public: ObSetMemberListBatchArg() { reset(); } ~ObSetMemberListBatchArg() {} bool is_valid() const; void reset(); int assign(const ObSetMemberListBatchArg& other); int add_arg(const common::ObPartitionKey& key, const common::ObMemberList& member_list); bool reach_concurrency_limit() const { return args_.count() >= MAX_COUNT; } bool has_task() const { return args_.count() > 0; } DECLARE_TO_STRING; common::ObSArray args_; int64_t timestamp_; // Used to verify asynchronous rpc return packets private: DISALLOW_COPY_AND_ASSIGN(ObSetMemberListBatchArg); }; struct ObCreatePartitionBatchRes { OB_UNIS_VERSION(1); public: ObCreatePartitionBatchRes() : ret_list_(), timestamp_(common::OB_INVALID_TIMESTAMP) {} ~ObCreatePartitionBatchRes() {} inline void reset(); int assign(const ObCreatePartitionBatchRes& other); inline void reuse(); DECLARE_TO_STRING; // response includes all rets common::ObSArray ret_list_; int64_t timestamp_; private: DISALLOW_COPY_AND_ASSIGN(ObCreatePartitionBatchRes); }; struct ObGetMinSSTableSchemaVersionRes { OB_UNIS_VERSION(1); public: ObGetMinSSTableSchemaVersionRes() : ret_list_() {} ~ObGetMinSSTableSchemaVersionRes() { reset(); } inline void reset() { ret_list_.reset(); } inline void reuse() { ret_list_.reuse(); } TO_STRING_KV(K_(ret_list)); // response includes all rets common::ObSArray ret_list_; private: DISALLOW_COPY_AND_ASSIGN(ObGetMinSSTableSchemaVersionRes); }; struct ObCheckUniqueIndexRequestArg { OB_UNIS_VERSION(1); public: ObCheckUniqueIndexRequestArg() { reset(); } ~ObCheckUniqueIndexRequestArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id), K_(schema_version)); public: common::ObPartitionKey pkey_; uint64_t index_id_; int64_t schema_version_; private: DISALLOW_COPY_AND_ASSIGN(ObCheckUniqueIndexRequestArg); }; struct ObCheckUniqueIndexResponseArg { OB_UNIS_VERSION(1); public: ObCheckUniqueIndexResponseArg() { reset(); } ~ObCheckUniqueIndexResponseArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id), K_(ret_code), K_(is_valid)); public: common::ObPartitionKey pkey_; uint64_t index_id_; int ret_code_; bool is_valid_; private: DISALLOW_COPY_AND_ASSIGN(ObCheckUniqueIndexResponseArg); }; struct ObCalcColumnChecksumRequestArg { OB_UNIS_VERSION(1); public: ObCalcColumnChecksumRequestArg() { reset(); } ~ObCalcColumnChecksumRequestArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id), K_(schema_version), K_(execution_id), K_(snapshot_version)); public: common::ObPartitionKey pkey_; uint64_t index_id_; int64_t schema_version_; uint64_t execution_id_; int64_t snapshot_version_; private: DISALLOW_COPY_AND_ASSIGN(ObCalcColumnChecksumRequestArg); }; struct ObCalcColumnChecksumResponseArg { OB_UNIS_VERSION(1); public: ObCalcColumnChecksumResponseArg() { reset(); } ~ObCalcColumnChecksumResponseArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id), K_(ret_code)); public: common::ObPartitionKey pkey_; uint64_t index_id_; int ret_code_; private: DISALLOW_COPY_AND_ASSIGN(ObCalcColumnChecksumResponseArg); }; struct ObCheckSingleReplicaMajorSSTableExistArg { OB_UNIS_VERSION(1); public: ObCheckSingleReplicaMajorSSTableExistArg() { reset(); } ~ObCheckSingleReplicaMajorSSTableExistArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id)); common::ObPartitionKey pkey_; uint64_t index_id_; private: DISALLOW_COPY_AND_ASSIGN(ObCheckSingleReplicaMajorSSTableExistArg); }; struct ObCheckSingleReplicaMajorSSTableExistResult { OB_UNIS_VERSION(1); public: ObCheckSingleReplicaMajorSSTableExistResult() { reset(); } ~ObCheckSingleReplicaMajorSSTableExistResult() = default; void reset(); TO_STRING_KV(K_(timestamp)); int64_t timestamp_; }; struct ObCheckAllReplicaMajorSSTableExistArg { OB_UNIS_VERSION(1); public: ObCheckAllReplicaMajorSSTableExistArg() { reset(); } ~ObCheckAllReplicaMajorSSTableExistArg() = default; bool is_valid() const; void reset(); TO_STRING_KV(K_(pkey), K_(index_id)); common::ObPartitionKey pkey_; uint64_t index_id_; private: DISALLOW_COPY_AND_ASSIGN(ObCheckAllReplicaMajorSSTableExistArg); }; struct ObCheckAllReplicaMajorSSTableExistResult { OB_UNIS_VERSION(1); public: ObCheckAllReplicaMajorSSTableExistResult() { reset(); } ~ObCheckAllReplicaMajorSSTableExistResult() = default; void reset(); TO_STRING_KV(K_(max_timestamp)); int64_t max_timestamp_; }; // TODO(liuyue):delete these two rpc struct ObMigrateArg { OB_UNIS_VERSION(1); public: ObMigrateArg() : keep_src_(false) {} bool is_valid() const { return partition_key_.is_valid() && src_.is_valid() && dst_.is_valid(); } DECLARE_TO_STRING; common::ObPartitionKey partition_key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember replace_; bool keep_src_; }; //----Structs for partition online/offline---- struct ObCopySSTableArg { OB_UNIS_VERSION(1); public: ObCopySSTableArg() : key_(), src_(), dst_(), task_id_(), type_(common::OB_COPY_SSTABLE_TYPE_INVALID), index_table_id_(common::OB_INVALID_ID), priority_(common::ObReplicaOpPriority::PRIO_LOW), cluster_id_(common::OB_INVALID_ID), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && common::OB_COPY_SSTABLE_TYPE_INVALID != type_ && (common::OB_COPY_SSTABLE_TYPE_LOCAL_INDEX != type_ || common::OB_INVALID_ID != index_table_id_); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(cluster_id), K_(task_id), K_(type), K_(index_table_id), K_(priority), K(skip_change_member_list_), K(switch_epoch_)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; share::ObTaskId task_id_; common::ObCopySSTableType type_; uint64_t index_table_id_; common::ObReplicaOpPriority priority_; int64_t cluster_id_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObCopySSTableRes { OB_UNIS_VERSION(1); public: ObCopySSTableRes() : key_(), src_(), dst_(), data_src_(), type_(common::OB_COPY_SSTABLE_TYPE_INVALID), index_table_id_(common::OB_INVALID_ID), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid() && common::OB_COPY_SSTABLE_TYPE_INVALID != type_ && (common::OB_COPY_SSTABLE_TYPE_LOCAL_INDEX != type_ || common::OB_INVALID_ID != index_table_id_); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(data_src), K_(result), K_(type), K_(index_table_id)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; common::ObCopySSTableType type_; uint64_t index_table_id_; int64_t result_; }; struct ObAddReplicaArg { OB_UNIS_VERSION(1); public: ObAddReplicaArg() : key_(), src_(), dst_(), quorum_(0), reserved_modify_quorum_type_(common::MAX_MODIFY_QUORUM_TYPE), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_HIGH), cluster_id_(common::OB_INVALID_ID), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION), pg_file_id_(common::OB_INVALID_DATA_FILE_ID) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && src_.get_server() != dst_.get_server() && is_replica_op_priority_valid(priority_); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(quorum), K_(reserved_modify_quorum_type), K(task_id_), K_(priority), K(cluster_id_), K_(skip_change_member_list), K_(switch_epoch), K_(pg_file_id)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; int64_t quorum_; common::ObModifyQuorumType reserved_modify_quorum_type_; // unused share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; int64_t cluster_id_; bool skip_change_member_list_; int64_t switch_epoch_; int64_t pg_file_id_; }; struct ObAddReplicaRes { OB_UNIS_VERSION(2); public: ObAddReplicaRes() : key_(), src_(), dst_(), data_src_(), quorum_(0), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(quorum), K_(data_src), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; int64_t quorum_; int64_t result_; }; struct ObRebuildReplicaArg { OB_UNIS_VERSION(1); public: ObRebuildReplicaArg() : key_(), src_(), dst_(), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_HIGH), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && is_replica_op_priority_valid(priority_); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(task_id), K_(priority), K_(skip_change_member_list), K_(switch_epoch)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObRebuildReplicaRes { OB_UNIS_VERSION(1); public: ObRebuildReplicaRes() : key_(), src_(), dst_(), data_src_(), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(data_src), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; int64_t result_; }; struct ObRemoveNonPaxosReplicaArg { OB_UNIS_VERSION(1); public: ObRemoveNonPaxosReplicaArg() : key_(), dst_(), task_id_(), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && dst_.is_valid(); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(dst), K_(task_id), K_(skip_change_member_list), K_(switch_epoch)); common::ObPartitionKey key_; common::ObReplicaMember dst_; share::ObTaskId task_id_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObRemoveNonPaxosReplicaBatchResult { public: ObRemoveNonPaxosReplicaBatchResult() : return_array_() {} public: TO_STRING_KV(K_(return_array)); public: common::ObSArray return_array_; OB_UNIS_VERSION(3); }; struct ObRestoreReplicaArg { OB_UNIS_VERSION(1); public: ObRestoreReplicaArg() : key_(), src_(), dst_(), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_LOW), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && is_replica_op_priority_valid(priority_); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(priority), K_(skip_change_member_list), K_(switch_epoch)); common::ObPartitionKey key_; share::ObRestoreArgs src_; common::ObReplicaMember dst_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObRestoreReplicaRes { OB_UNIS_VERSION(1); public: ObRestoreReplicaRes() : key_(), src_(), dst_(), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(result)); common::ObPartitionKey key_; share::ObRestoreArgs src_; common::ObReplicaMember dst_; int64_t result_; }; struct ObPhyRestoreReplicaArg { OB_UNIS_VERSION(1); public: ObPhyRestoreReplicaArg(); bool is_valid() const; TO_STRING_KV(K_(key), K_(src), K_(dst), K_(task_id), K_(priority)); common::ObPartitionKey key_; share::ObPhysicalRestoreArg src_; common::ObReplicaMember dst_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; }; struct ObPhyRestoreReplicaRes { OB_UNIS_VERSION(1); public: ObPhyRestoreReplicaRes(); bool is_valid() const; TO_STRING_KV(K_(key), K_(src), K_(dst), K_(result)); common::ObPartitionKey key_; share::ObPhysicalRestoreArg src_; common::ObReplicaMember dst_; int64_t result_; }; struct ObMigrateReplicaArg { OB_UNIS_VERSION(1); public: ObMigrateReplicaArg() : key_(), src_(), dst_(), data_source_(), quorum_(0), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_LOW), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION), migrate_mode_(MigrateMode::MT_LOCAL_FS_MODE) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && data_source_.is_valid() && src_.get_server() != dst_.get_server() && data_source_.get_server() != dst_.get_server() && is_replica_op_priority_valid(priority_) && migrate_mode_ < obrpc::MigrateMode::MT_MAX; if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(data_source), K_(quorum), K_(task_id), K_(priority), K_(skip_change_member_list), K_(switch_epoch), K_(migrate_mode)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_source_; int64_t quorum_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; bool skip_change_member_list_; int64_t switch_epoch_; MigrateMode migrate_mode_; }; struct ObMigrateReplicaRes { OB_UNIS_VERSION(2); public: ObMigrateReplicaRes() : key_(), src_(), dst_(), data_src_(), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(result), K_(data_src)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; int64_t result_; }; struct ObChangeReplicaArg { OB_UNIS_VERSION(1); public: ObChangeReplicaArg() : key_(), src_(), dst_(), quorum_(0), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_LOW), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const; TO_STRING_KV( K_(key), K_(src), K_(dst), K_(quorum), K_(task_id), K_(priority), K_(skip_change_member_list), K_(switch_epoch)) common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; int64_t quorum_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObChangeReplicaRes { OB_UNIS_VERSION(1); public: ObChangeReplicaRes() : key_(), src_(), dst_(), data_src_(), quorum_(0), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(quorum), K_(data_src), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; int64_t quorum_; int64_t result_; }; struct ObBackupArg { OB_UNIS_VERSION(1); public: ObBackupArg() : key_(), src_(), dst_(), physical_backup_arg_(), task_id_(), priority_(common::ObReplicaOpPriority::PRIO_HIGH), cluster_id_(common::OB_INVALID_ID), skip_change_member_list_(false), switch_epoch_(common::OB_INVALID_VERSION) {} bool is_valid() const { bool bret = false; bret = key_.is_valid() && src_.is_valid() && dst_.is_valid() && physical_backup_arg_.is_valid(); if (bret && !IS_CLUSTER_VERSION_BEFORE_2200) { bret = (common::OB_INVALID_VERSION != switch_epoch_); } return bret; } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(physical_backup_arg), K_(cluster_id), K_(task_id), K_(priority), K(skip_change_member_list_), K(switch_epoch_)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; share::ObPhysicalBackupArg physical_backup_arg_; share::ObTaskId task_id_; common::ObReplicaOpPriority priority_; int64_t cluster_id_; bool skip_change_member_list_; int64_t switch_epoch_; }; struct ObValidateArg { OB_UNIS_VERSION(1); public: ObValidateArg() : trace_id_(), dst_(), physical_validate_arg_(), priority_(common::ObReplicaOpPriority::PRIO_LOW) {} int assign(const ObValidateArg& arg); bool is_valid() const { return physical_validate_arg_.is_valid(); } TO_STRING_KV(K_(trace_id), K_(dst), K_(physical_validate_arg), K_(priority)); share::ObTaskId trace_id_; common::ObReplicaMember dst_; share::ObPhysicalValidateArg physical_validate_arg_; common::ObReplicaOpPriority priority_; }; struct ObStandbyCutDataTaskArg { OB_UNIS_VERSION(1); public: ObStandbyCutDataTaskArg() : dst_(), pkey_() {} bool is_valid() const { return pkey_.is_valid(); } TO_STRING_KV(K_(dst), K_(pkey)); common::ObReplicaMember dst_; common::ObPartitionKey pkey_; }; struct ObMigrateBackupsetArg { OB_UNIS_VERSION(1); public: ObMigrateBackupsetArg(); int assign(const ObMigrateBackupsetArg& arg); bool is_valid() const; TO_STRING_KV(K_(backup_set_id), K_(pg_key), K_(backup_backupset_arg)); uint64_t backup_set_id_; common::ObPartitionKey pg_key_; share::ObBackupBackupsetArg backup_backupset_arg_; }; struct ObBackupRes { OB_UNIS_VERSION(1); public: ObBackupRes() : key_(), src_(), dst_(), data_src_(), physical_backup_arg_(), result_(0) {} bool is_valid() const { return key_.is_valid() && src_.is_valid() && dst_.is_valid() && physical_backup_arg_.is_valid(); } TO_STRING_KV(K_(key), K_(src), K_(dst), K_(data_src), K_(physical_backup_arg), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember src_; common::ObReplicaMember dst_; common::ObReplicaMember data_src_; share::ObPhysicalBackupArg physical_backup_arg_; int64_t result_; }; struct ObValidateRes { OB_UNIS_VERSION(1); public: ObValidateRes() : key_(), dst_(), validate_arg_(), result_(0) {} int assign(const ObValidateRes& res); bool is_valid() const { return key_.is_valid() && dst_.is_valid() && validate_arg_.is_valid(); } TO_STRING_KV(K_(key), K_(dst), K_(validate_arg), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember dst_; share::ObPhysicalValidateArg validate_arg_; int64_t result_; }; //----End structs for partition online/offline---- struct ObAddReplicaBatchRes { OB_UNIS_VERSION(2); public: ObAddReplicaBatchRes() : res_array_() {} public: bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObRebuildReplicaBatchRes { OB_UNIS_VERSION(1); public: ObRebuildReplicaBatchRes() : res_array_() {} public: bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObCopySSTableBatchRes { OB_UNIS_VERSION(1); public: ObCopySSTableBatchRes() : res_array_(), type_(common::OB_COPY_SSTABLE_TYPE_INVALID) {} public: bool is_valid() const; TO_STRING_KV(K_(res_array), K_(type)); public: common::ObSArray res_array_; common::ObCopySSTableType type_; }; struct ObMigrateReplicaBatchRes { OB_UNIS_VERSION(2); public: ObMigrateReplicaBatchRes() : res_array_() {} bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObChangeReplicaBatchRes { OB_UNIS_VERSION(1); public: ObChangeReplicaBatchRes() : res_array_() {} public: bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObStandbyCutDataTaskRes { OB_UNIS_VERSION(1); public: ObStandbyCutDataTaskRes() : key_(), dst_(), result_(0) {} bool is_valid() const { return key_.is_valid() && dst_.is_valid(); } TO_STRING_KV(K_(key), K_(dst), K_(result)); common::ObPartitionKey key_; common::ObReplicaMember dst_; int64_t result_; }; struct ObStandbyCutDataBatchTaskRes { OB_UNIS_VERSION(1); public: ObStandbyCutDataBatchTaskRes() : res_array_() {} public: int assign(const struct ObStandbyCutDataBatchTaskRes& res); bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObBackupBatchRes { OB_UNIS_VERSION(1); public: ObBackupBatchRes() : res_array_() {} public: bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObValidateBatchRes { OB_UNIS_VERSION(1); public: ObValidateBatchRes() : res_array_() {} public: int assign(const ObValidateBatchRes& res); bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; struct ObPGBackupArchiveLogArg { OB_UNIS_VERSION(1); public: ObPGBackupArchiveLogArg(); public: bool is_valid() const; int assign(const ObPGBackupArchiveLogArg& arg); TO_STRING_KV(K_(archive_round), K_(pg_key)); public: int64_t archive_round_; common::ObPGKey pg_key_; }; struct ObPGBackupArchiveLogRes { OB_UNIS_VERSION(1); public: ObPGBackupArchiveLogRes(); public: bool is_valid() const; int assign(const ObPGBackupArchiveLogRes& res); TO_STRING_KV(K_(result), K_(finished), K_(checkpoint_ts), K_(pg_key)); public: int result_; bool finished_; int64_t checkpoint_ts_; common::ObPGKey pg_key_; }; struct ObBackupArchiveLogBatchArg { OB_UNIS_VERSION(1); public: ObBackupArchiveLogBatchArg(); public: bool is_valid() const; int assign(const ObBackupArchiveLogBatchArg& arg); TO_STRING_KV(K_(tenant_id), K_(archive_round), K_(checkpoint_ts), K_(task_id), K_(src_root_path), K_(src_storage_info), K_(dst_root_path), K_(dst_storage_info), K_(arg_array)); public: uint64_t tenant_id_; int64_t archive_round_; int64_t piece_id_; int64_t create_date_; int64_t job_id_; int64_t checkpoint_ts_; // rs_checkpoint_ts share::ObTaskId task_id_; char src_root_path_[share::OB_MAX_BACKUP_PATH_LENGTH]; char src_storage_info_[share::OB_MAX_BACKUP_STORAGE_INFO_LENGTH]; char dst_root_path_[share::OB_MAX_BACKUP_PATH_LENGTH]; char dst_storage_info_[share::OB_MAX_BACKUP_STORAGE_INFO_LENGTH]; common::ObSArray arg_array_; }; struct ObBackupArchiveLogBatchRes { OB_UNIS_VERSION(1); public: ObBackupArchiveLogBatchRes(); public: bool is_valid() const; bool is_interrupted() const; int assign(const ObBackupArchiveLogBatchRes& arg); int get_min_checkpoint_ts(int64_t& checkpoint_ts) const; int get_finished_pg_list(common::ObIArray& pg_list) const; int get_failed_pg_list(common::ObIArray& pg_list) const; TO_STRING_KV( K_(server), K_(tenant_id), K_(archive_round), K_(piece_id), K_(checkpoint_ts), K_(job_id), K_(res_array)); public: common::ObAddr server_; uint64_t tenant_id_; int64_t archive_round_; int64_t piece_id_; int64_t job_id_; int64_t checkpoint_ts_; // rs checkpoint ts common::ObSArray res_array_; }; struct ObBackupBackupsetReplicaRes { OB_UNIS_VERSION(1); public: ObBackupBackupsetReplicaRes(); public: int assign(const ObBackupBackupsetReplicaRes& res); bool is_valid() const; TO_STRING_KV(K_(key), K_(dst), K_(result)); public: common::ObPartitionKey key_; common::ObReplicaMember dst_; share::ObBackupBackupsetArg arg_; int result_; }; struct ObBackupBackupsetBatchRes { OB_UNIS_VERSION(1); public: int assign(const ObBackupBackupsetBatchRes& res); bool is_valid() const; TO_STRING_KV(K_(res_array)); public: common::ObSArray res_array_; }; // ---Structs for partition batch online/offline--- struct ObAddReplicaBatchArg { OB_UNIS_VERSION(1); public: ObAddReplicaBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObRemoveNonPaxosReplicaBatchArg { OB_UNIS_VERSION(1); public: ObRemoveNonPaxosReplicaBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObMigrateReplicaBatchArg { OB_UNIS_VERSION(1); public: ObMigrateReplicaBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObChangeReplicaBatchArg { OB_UNIS_VERSION(1); public: ObChangeReplicaBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObCopySSTableBatchArg { OB_UNIS_VERSION(1); public: ObCopySSTableBatchArg() : arg_array_(), timeout_ts_(0), task_id_(), type_(common::OB_COPY_SSTABLE_TYPE_INVALID) {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id), K_(type)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; common::ObCopySSTableType type_; }; struct ObRebuildReplicaBatchArg { OB_UNIS_VERSION(1); public: ObRebuildReplicaBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObServerCopyLocalIndexSSTableArg { OB_UNIS_VERSION(1); public: ObServerCopyLocalIndexSSTableArg() : data_src_(), dst_(), pkey_(), index_table_id_(common::OB_INVALID_ID), cluster_id_(common::OB_INVALID_ID), data_size_(0) {} public: bool is_valid() const; TO_STRING_KV(K_(data_src), K_(dst), K_(pkey), K_(index_table_id), K_(cluster_id), K_(data_size)); public: common::ObAddr data_src_; common::ObAddr dst_; common::ObPartitionKey pkey_; uint64_t index_table_id_; int64_t cluster_id_; int64_t data_size_; }; struct ObBackupBatchArg { OB_UNIS_VERSION(1); public: ObBackupBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; enum ObReplicaMovingType : int8_t { REPLICA_MOVING_TYPE_INVALID = 0, REPLICA_MOVING_TYPE_ADD_REPLICA, REPLICA_MOVING_TYPE_DROP_REPLICA, REPLICA_MOVING_TYPE_MAX }; struct ObAuthReplicaMovingkArg { OB_UNIS_VERSION(1); public: ObAuthReplicaMovingkArg() : file_id_(0), type_(REPLICA_MOVING_TYPE_INVALID) {} bool is_valid() const; TO_STRING_KV(K(pg_key_), K(addr_), K(file_id_), K(type_)); public: common::ObPGKey pg_key_; common::ObAddr addr_; int64_t file_id_; ObReplicaMovingType type_; }; struct ObValidateBatchArg { OB_UNIS_VERSION(1); public: ObValidateBatchArg() : arg_array_(), timeout_ts_(0), task_id_() {} public: int assign(const ObValidateBatchArg& arg); bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(task_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; }; struct ObStandbyCutDataBatchTaskArg { OB_UNIS_VERSION(1); public: ObStandbyCutDataBatchTaskArg() : arg_array_(), timeout_ts_(0), trace_id_(), fo_trace_id_(), flashback_ts_(0), switchover_epoch_(0) {} public: int init(const int64_t timeout, const share::ObTaskId& task_id, const common::ObCurTraceId::TraceId& fo_trace_id, const int64_t flashback_ts, const int64_t switchover_epoch); bool is_valid() const; TO_STRING_KV(K_(arg_array), K_(timeout_ts), K_(trace_id), K_(flashback_ts), K_(switchover_epoch), K_(fo_trace_id)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId trace_id_; common::ObCurTraceId::TraceId fo_trace_id_; int64_t flashback_ts_; int64_t switchover_epoch_; }; struct ObBackupBackupsetBatchArg { OB_UNIS_VERSION(1); public: ObBackupBackupsetBatchArg() : arg_array_(), timeout_ts_(), task_id_(), tenant_dropped_(false) {} public: int assign(const ObBackupBackupsetBatchArg& res); bool is_valid() const; TO_STRING_KV(K_(timeout_ts), K_(task_id), K_(tenant_dropped)); public: common::ObSArray arg_array_; int64_t timeout_ts_; share::ObTaskId task_id_; bool tenant_dropped_; }; //----Structs for managing privileges---- struct ObMajorFreezeArg { OB_UNIS_VERSION(1); public: ObMajorFreezeArg() : frozen_version_(0), schema_version_(0), frozen_timestamp_(0) {} inline void reset(); inline void reuse(); bool is_valid() const; DECLARE_TO_STRING; int64_t frozen_version_; int64_t schema_version_; int64_t frozen_timestamp_; private: // DISALLOW_COPY_AND_ASSIGN(ObMajorFreezeArg); }; struct ObSetReplicaNumArg { OB_UNIS_VERSION(1); public: ObSetReplicaNumArg() : partition_key_(), replica_num_(0) {} ~ObSetReplicaNumArg() {} inline void reset(); bool is_valid() const { return partition_key_.is_valid() && replica_num_ > 0; } DECLARE_TO_STRING; common::ObPartitionKey partition_key_; int64_t replica_num_; }; struct ObSetParentArg { OB_UNIS_VERSION(1); public: ObSetParentArg() : partition_key_(), parent_addr_() {} ~ObSetParentArg() {} inline void reset(); bool is_valid() const { return partition_key_.is_valid() && parent_addr_.is_valid(); } DECLARE_TO_STRING; common::ObPartitionKey partition_key_; common::ObAddr parent_addr_; }; struct ObSwitchLeaderArg { OB_UNIS_VERSION(1); public: ObSwitchLeaderArg() : partition_key_(), leader_addr_() {} ~ObSwitchLeaderArg() {} inline void reset(); bool is_valid() const { return partition_key_.is_valid() && leader_addr_.is_valid(); } DECLARE_TO_STRING; common::ObPartitionKey partition_key_; common::ObAddr leader_addr_; }; struct ObSwitchSchemaArg { OB_UNIS_VERSION(1); public: explicit ObSwitchSchemaArg() : schema_info_(), force_refresh_(false) {} explicit ObSwitchSchemaArg(const share::schema::ObRefreshSchemaInfo& schema_info, bool force_refresh) : schema_info_(schema_info), force_refresh_(force_refresh) {} ~ObSwitchSchemaArg() {} void reset(); bool is_valid() const { return schema_info_.get_schema_version() > 0; } DECLARE_TO_STRING; share::schema::ObRefreshSchemaInfo schema_info_; bool force_refresh_; }; struct ObCheckSchemaVersionElapsedArg { OB_UNIS_VERSION(1); public: ObCheckSchemaVersionElapsedArg() : pkey_(), schema_version_(0) {} bool is_valid() const { return pkey_.is_valid() && schema_version_ > 0; } void reuse() { pkey_.reset(); schema_version_ = 0; } int build(rootserver::ObGlobalIndexTask* task, common::ObPartitionKey& pkey); TO_STRING_KV(K_(pkey), K_(schema_version)); common::ObPartitionKey pkey_; int64_t schema_version_; }; struct ObCheckCtxCreateTimestampElapsedArg { OB_UNIS_VERSION(1); public: ObCheckCtxCreateTimestampElapsedArg() : pkey_(), sstable_exist_ts_(0) {} bool is_valid() const { return pkey_.is_valid() && sstable_exist_ts_ > 0; } void reuse() { pkey_.reset(); sstable_exist_ts_ = 0; } int build(rootserver::ObGlobalIndexTask* task, common::ObPartitionKey& pkey); TO_STRING_KV(K_(pkey), K_(sstable_exist_ts)); common::ObPartitionKey pkey_; int64_t sstable_exist_ts_; }; struct ObCheckSchemaVersionElapsedResult { OB_UNIS_VERSION(1); public: ObCheckSchemaVersionElapsedResult() : snapshot_(common::OB_INVALID_TIMESTAMP) {} bool is_valid() const { return snapshot_ != common::OB_INVALID_TIMESTAMP; } void reuse() { snapshot_ = common::OB_INVALID_TIMESTAMP; } TO_STRING_KV(K_(snapshot)); int64_t snapshot_; }; struct ObCheckCtxCreateTimestampElapsedResult { OB_UNIS_VERSION(1); public: ObCheckCtxCreateTimestampElapsedResult() : snapshot_(common::OB_INVALID_TIMESTAMP) {} bool is_valid() const { return snapshot_ != common::OB_INVALID_TIMESTAMP; } void reuse() { snapshot_ = common::OB_INVALID_TIMESTAMP; } TO_STRING_KV(K_(snapshot)); int64_t snapshot_; }; struct ObGetLeaderCandidatesArg { OB_UNIS_VERSION(1); public: ObGetLeaderCandidatesArg() : partitions_() {} void reuse() { partitions_.reuse(); } bool is_valid() const { return partitions_.count() > 0; } TO_STRING_KV(K_(partitions)); ObPartitionList partitions_; }; struct ObGetLeaderCandidatesV2Arg { OB_UNIS_VERSION(1); public: ObGetLeaderCandidatesV2Arg() : partitions_(), prep_candidates_() {} void reuse() { partitions_.reuse(); prep_candidates_.reuse(); } bool is_valid() const { return ((partitions_.count() > 0) && (prep_candidates_.count() > 0)); } TO_STRING_KV(K_(partitions)); ObPartitionList partitions_; ObServerList prep_candidates_; }; class CandidateStatus { OB_UNIS_VERSION(1); public: CandidateStatus() : candidate_status_(0) {} virtual ~CandidateStatus() {} public: void set_in_black_list(const bool in_black_list) { if (in_black_list) { in_black_list_ = 1; } else { in_black_list_ = 0; } } bool get_in_black_list() const { bool ret_in_black_list = false; if (0 == in_black_list_) { // false, do nothing } else { ret_in_black_list = true; } return ret_in_black_list; } TO_STRING_KV("in_black_list", get_in_black_list()); private: union { uint64_t candidate_status_; struct { uint64_t in_black_list_ : 1; // Boolean uint64_t reserved_ : 63; }; }; }; typedef common::ObSArray CandidateStatusList; struct ObGetLeaderCandidatesResult { OB_UNIS_VERSION(1); public: ObGetLeaderCandidatesResult() : candidates_() {} void reuse() { candidates_.reuse(); candidate_status_array_.reuse(); } TO_STRING_KV(K_(candidates)); common::ObSArray candidates_; common::ObSArray candidate_status_array_; }; //----Structs for managing privileges---- struct ObAccountArg { OB_UNIS_VERSION(1); public: ObAccountArg() : user_name_(), host_name_(), is_role_(false) {} ObAccountArg(const common::ObString& user_name, const common::ObString& host_name) : user_name_(user_name), host_name_(host_name), is_role_(false) {} ObAccountArg(const char* user_name, const char* host_name) : user_name_(user_name), host_name_(host_name), is_role_(false) {} ObAccountArg(const common::ObString& user_name, const common::ObString& host_name, const bool is_role) : user_name_(user_name), host_name_(host_name), is_role_(is_role) {} ObAccountArg(const char* user_name, const char* host_name, const bool is_role) : user_name_(user_name), host_name_(host_name), is_role_(is_role) {} bool is_valid() const { return !user_name_.empty(); } bool is_default_host_name() const { return 0 == host_name_.compare(common::OB_DEFAULT_HOST_NAME); } TO_STRING_KV(K_(user_name), K_(host_name), K_(is_role)); common::ObString user_name_; common::ObString host_name_; bool is_role_; }; struct ObCreateUserArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateUserArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), if_not_exist_(false), creator_id_(common::OB_INVALID_ID), primary_zone_() {} virtual ~ObCreateUserArg() {} bool is_valid() const; int assign(const ObCreateUserArg& other); TO_STRING_KV(K_(tenant_id), K_(user_infos)); uint64_t tenant_id_; bool if_not_exist_; common::ObSArray user_infos_; uint64_t creator_id_; common::ObString primary_zone_; // only used in oracle mode }; struct ObDropUserArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropUserArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), is_role_(false) {} virtual ~ObDropUserArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(users), K_(hosts), K_(is_role)); uint64_t tenant_id_; common::ObSArray users_; common::ObSArray hosts_; // can not use ObAccountArg for compatibility bool is_role_; }; struct ObRenameUserArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRenameUserArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID) {} virtual ~ObRenameUserArg() {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(old_users), K_(old_hosts), K_(new_users), K_(new_hosts)); uint64_t tenant_id_; common::ObSArray old_users_; common::ObSArray new_users_; common::ObSArray old_hosts_; common::ObSArray new_hosts_; }; struct ObSetPasswdArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObSetPasswdArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), ssl_type_(share::schema::ObSSLType::SSL_TYPE_NOT_SPECIFIED), modify_max_connections_(false), max_connections_per_hour_(OB_INVALID_ID), max_user_connections_(OB_INVALID_ID) {} virtual ~ObSetPasswdArg() {} bool is_valid() const; TO_STRING_KV( K_(tenant_id), K_(user), K_(host), K_(passwd), K_(ssl_type), K_(ssl_cipher), K_(x509_issuer), K_(x509_subject), K_(modify_max_connections), K_(max_connections_per_hour), K_(max_user_connections)); uint64_t tenant_id_; common::ObString user_; common::ObString passwd_; common::ObString host_; share::schema::ObSSLType ssl_type_; common::ObString ssl_cipher_; common::ObString x509_issuer_; common::ObString x509_subject_; bool modify_max_connections_; uint64_t max_connections_per_hour_; uint64_t max_user_connections_; }; struct ObLockUserArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObLockUserArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), locked_(false) {} virtual ~ObLockUserArg() {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(users), K_(hosts), K_(locked)); uint64_t tenant_id_; common::ObSArray users_; common::ObSArray hosts_; bool locked_; }; struct ObAlterUserProfileArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObAlterUserProfileArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_TENANT_ID), user_name_(), host_name_(), profile_name_(), user_id_(common::OB_INVALID_TENANT_ID), default_role_flag_(common::OB_INVALID_TENANT_ID), role_id_array_() {} virtual ~ObAlterUserProfileArg() {} int assign(const ObAlterUserProfileArg& other); bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(user_name), K_(host_name), K_(profile_name)); uint64_t tenant_id_; common::ObString user_name_; common::ObString host_name_; common::ObString profile_name_; uint64_t user_id_; uint64_t default_role_flag_; common::ObSEArray role_id_array_; }; struct ObGrantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObGrantArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), priv_level_(share::schema::OB_PRIV_INVALID_LEVEL), priv_set_(0), users_passwd_(), hosts_(), need_create_user_(false), has_create_user_priv_(false), roles_(), option_(0), sys_priv_array_(), obj_priv_array_(), object_type_(share::schema::ObObjectType::INVALID), object_id_(common::OB_INVALID_ID), ins_col_ids_(), upd_col_ids_(), ref_col_ids_(), grantor_id_(common::OB_INVALID_ID), remain_roles_(), is_inner_(false) {} virtual ~ObGrantArg() {} bool is_valid() const; int assign(const ObGrantArg& other); virtual bool is_allow_when_disable_ddl() const; TO_STRING_KV(K_(tenant_id), K_(priv_level), K_(db), K_(table), K_(priv_set), K_(users_passwd), K_(hosts), K_(need_create_user), K_(has_create_user_priv), K_(option), K_(object_type), K_(object_id), K_(grantor_id), K_(ins_col_ids), K_(upd_col_ids), K_(ref_col_ids), K_(grantor_id)); uint64_t tenant_id_; share::schema::ObPrivLevel priv_level_; common::ObString db_; common::ObString table_; ObPrivSet priv_set_; common::ObSArray users_passwd_; common::ObSArray hosts_; bool need_create_user_; bool has_create_user_priv_; common::ObSArray roles_; uint64_t option_; share::ObRawPrivArray sys_priv_array_; share::ObRawObjPrivArray obj_priv_array_; share::schema::ObObjectType object_type_; uint64_t object_id_; common::ObSEArray ins_col_ids_; common::ObSEArray upd_col_ids_; common::ObSEArray ref_col_ids_; uint64_t grantor_id_; // used to save the user_name and host_name that cannot be stored in role[0] and role[1] // to support grant xxx to multiple user in oracle mode common::ObSArray remain_roles_; bool is_inner_; }; struct ObStandbyGrantArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObStandbyGrantArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), user_id_(0), db_(), table_(), priv_level_(share::schema::OB_PRIV_INVALID_LEVEL), priv_set_() {} virtual ~ObStandbyGrantArg() {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(user_id), K_(priv_level), K_(priv_set), K_(db), K_(table), K_(priv_level)); uint64_t tenant_id_; uint64_t user_id_; common::ObString db_; common::ObString table_; share::schema::ObPrivLevel priv_level_; ObPrivSet priv_set_; share::ObRawObjPrivArray obj_priv_array_; }; struct ObRevokeUserArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRevokeUserArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), user_id_(common::OB_INVALID_ID), priv_set_(0), revoke_all_(false), role_ids_() {} bool is_valid() const; TO_STRING_KV( K_(tenant_id), K_(user_id), "priv_set", share::schema::ObPrintPrivSet(priv_set_), K_(revoke_all), K_(role_ids)); uint64_t tenant_id_; uint64_t user_id_; ObPrivSet priv_set_; bool revoke_all_; common::ObSArray role_ids_; }; struct ObRevokeDBArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRevokeDBArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), user_id_(common::OB_INVALID_ID), priv_set_(0) {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(user_id), K_(db), "priv_set", share::schema::ObPrintPrivSet(priv_set_)); uint64_t tenant_id_; uint64_t user_id_; common::ObString db_; ObPrivSet priv_set_; }; struct ObRevokeTableArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRevokeTableArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), user_id_(common::OB_INVALID_ID), priv_set_(0), grant_(true), obj_id_(common::OB_INVALID_ID), obj_type_(common::OB_INVALID_ID), grantor_id_(common::OB_INVALID_ID), obj_priv_array_(), revoke_all_ora_(false) {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(user_id), K_(db), K_(table), "priv_set", share::schema::ObPrintPrivSet(priv_set_), K_(grant), K_(obj_id), K_(obj_type), K_(grantor_id), K_(obj_priv_array)); uint64_t tenant_id_; uint64_t user_id_; common::ObString db_; common::ObString table_; ObPrivSet priv_set_; bool grant_; uint64_t obj_id_; uint64_t obj_type_; uint64_t grantor_id_; share::ObRawObjPrivArray obj_priv_array_; bool revoke_all_ora_; }; struct ObRevokeSysPrivArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRevokeSysPrivArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), grantee_id_(common::OB_INVALID_ID), sys_priv_array_() {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(grantee_id), K_(sys_priv_array)); uint64_t tenant_id_; uint64_t grantee_id_; share::ObRawPrivArray sys_priv_array_; }; struct ObCreateRoleArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateRoleArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID) {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(user_infos)); uint64_t tenant_id_; // role and user share the same user schema structure common::ObSArray user_infos_; }; //----End of structs for managing privileges---- // system admin (alter system ...) rpc argument define struct ObAdminServerArg { OB_UNIS_VERSION(1); public: enum AdminServerOp { INVALID_OP = 0, ADD = 1, DELETE = 2, CANCEL_DELETE = 3, START = 4, STOP = 5, FORCE_STOP = 6, ISOLATE = 7, }; ObAdminServerArg() : servers_(), zone_(), force_stop_(false), op_(INVALID_OP) {} ~ObAdminServerArg() {} // zone can be empty, so don't check it bool is_valid() const { return servers_.count() > 0; } TO_STRING_KV(K_(servers), K_(zone), K_(force_stop), K_(op)); ObServerList servers_; common::ObZone zone_; bool force_stop_; AdminServerOp op_; }; struct ObAdminZoneArg { OB_UNIS_VERSION(1); public: enum AdminZoneOp { ADD = 1, DELETE = 2, START = 3, STOP = 4, MODIFY = 5, FORCE_STOP = 6, ISOLATE = 7, }; enum ALTER_ZONE_OPTION { ALTER_ZONE_REGION = 0, ALTER_ZONE_IDC = 1, ALTER_ZONE_TYPE = 2, ALTER_ZONE_MAX = 128, }; public: ObAdminZoneArg() : zone_(), region_(), idc_(), zone_type_(common::ObZoneType::ZONE_TYPE_INVALID), force_stop_(false), op_(ADD) {} ~ObAdminZoneArg() {} bool is_valid() const { return !zone_.is_empty(); } TO_STRING_KV(K_(zone), K_(region), K_(idc), K_(zone_type), K_(sql_stmt_str), K_(force_stop), K_(op)); common::ObZone zone_; common::ObRegion region_; common::ObIDC idc_; common::ObZoneType zone_type_; common::ObString sql_stmt_str_; common::ObBitSet alter_zone_options_; bool force_stop_; AdminZoneOp op_; }; struct ObAdminSwitchReplicaRoleArg { OB_UNIS_VERSION(1); public: ObAdminSwitchReplicaRoleArg() : role_(common::FOLLOWER), partition_key_(), server_(), zone_(), tenant_name_() {} ~ObAdminSwitchReplicaRoleArg() {} bool is_valid() const; TO_STRING_KV(K_(role), K_(partition_key), K_(server), K_(zone), K_(tenant_name)); common::ObRole role_; common::ObPartitionKey partition_key_; common::ObAddr server_; common::ObZone zone_; common::ObFixedLengthString tenant_name_; }; struct ObAdminSwitchRSRoleArg { OB_UNIS_VERSION(1); public: ObAdminSwitchRSRoleArg() : role_(common::FOLLOWER), server_(), zone_() {} ~ObAdminSwitchRSRoleArg() {} bool is_valid() const; TO_STRING_KV(K_(role), K_(server), K_(zone)); common::ObRole role_; common::ObAddr server_; common::ObZone zone_; }; struct ObAdminChangeReplicaArg { OB_UNIS_VERSION(1); public: ObAdminChangeReplicaArg() : partition_key_(), member_(), force_cmd_(false) {} ~ObAdminChangeReplicaArg() {} bool is_valid() const; TO_STRING_KV(K_(partition_key), K_(member), K_(force_cmd)); common::ObPartitionKey partition_key_; common::ObReplicaMember member_; bool force_cmd_; }; struct ObCheckGtsReplicaStopServer { OB_UNIS_VERSION(1); public: ObCheckGtsReplicaStopServer() : servers_() {} TO_STRING_KV(K_(servers)); int init(const common::ObIArray& servers) { int ret = common::OB_SUCCESS; servers_.reset(); if (OB_FAIL(servers_.assign(servers))) { SHARE_LOG(WARN, "fail to assign servers", K(ret)); } return ret; } bool is_valid() const { return servers_.count() > 0; } public: common::ObSArray servers_; }; struct ObCheckGtsReplicaStopZone { OB_UNIS_VERSION(1); public: ObCheckGtsReplicaStopZone() : zone_() {} ObCheckGtsReplicaStopZone(const common::ObZone& zone) : zone_(zone) {} TO_STRING_KV(K_(zone)); bool is_valid() const { return !zone_.is_empty(); } public: common::ObZone zone_; }; struct ObAdminDropReplicaArg { OB_UNIS_VERSION(1); public: ObAdminDropReplicaArg() : partition_key_(), server_(), zone_(), create_timestamp_(0), force_cmd_(false) {} ~ObAdminDropReplicaArg() {} bool is_valid() const; TO_STRING_KV(K_(partition_key), K_(server), K_(zone), K_(create_timestamp), K_(force_cmd)); common::ObPartitionKey partition_key_; common::ObAddr server_; common::ObZone zone_; int64_t create_timestamp_; bool force_cmd_; }; struct ObAdminAddDiskArg { OB_UNIS_VERSION(1); public: ObAdminAddDiskArg() : diskgroup_name_(), disk_path_(), alias_name_(), server_(), zone_() {} ~ObAdminAddDiskArg() {} bool is_valid() const; TO_STRING_KV(K_(diskgroup_name), K_(disk_path), K_(alias_name), K_(server), K_(zone)); common::ObString diskgroup_name_; common::ObString disk_path_; common::ObString alias_name_; common::ObAddr server_; common::ObZone zone_; }; struct ObAdminDropDiskArg { OB_UNIS_VERSION(1); public: ObAdminDropDiskArg() : diskgroup_name_(), alias_name_(), server_(), zone_() {} ~ObAdminDropDiskArg() {} TO_STRING_KV(K_(diskgroup_name), K_(alias_name), K_(server), K_(zone)); common::ObString diskgroup_name_; common::ObString alias_name_; common::ObAddr server_; common::ObZone zone_; }; struct ObAdminMigrateReplicaArg { OB_UNIS_VERSION(1); public: ObAdminMigrateReplicaArg() : is_copy_(false), partition_key_(), src_(), dest_(), force_cmd_(false) {} ~ObAdminMigrateReplicaArg() {} bool is_valid() const; TO_STRING_KV(K_(is_copy), K_(partition_key), K_(src), K_(dest), K_(force_cmd)); bool is_copy_; common::ObPartitionKey partition_key_; common::ObAddr src_; common::ObAddr dest_; bool force_cmd_; }; struct ObPhysicalRestoreTenantArg : public ObCmdArg { OB_UNIS_VERSION(1); public: ObPhysicalRestoreTenantArg(); virtual ~ObPhysicalRestoreTenantArg() {} bool is_valid() const; int assign(const ObPhysicalRestoreTenantArg& other); int add_table_item(const ObTableItem& item); TO_STRING_KV(K_(tenant_name), K_(uri), K_(restore_option), K_(restore_timestamp), K_(backup_tenant_name), K_(passwd_array), K_(table_items), K_(multi_uri)); common::ObString tenant_name_; common::ObString uri_; common::ObString restore_option_; int64_t restore_timestamp_; common::ObString backup_tenant_name_; common::ObString passwd_array_; // Password verification common::ObSArray table_items_; common::ObString multi_uri_; }; struct ObRestoreTenantArg : public ObCmdArg { OB_UNIS_VERSION(1); public: ObRestoreTenantArg() : ObCmdArg(), tenant_name_(), oss_uri_() {} bool is_valid() const { return !tenant_name_.is_empty() && !oss_uri_.empty(); } TO_STRING_KV(K_(tenant_name), K_(oss_uri)); common::ObFixedLengthString tenant_name_; common::ObString oss_uri_; }; struct ObRestorePartitionsArg { OB_UNIS_VERSION(1); public: ObRestorePartitionsArg() : schema_id_(common::OB_INVALID_ID), mode_(OB_CREATE_TABLE_MODE_RESTORE), partition_ids_(), schema_version_(common::OB_INVALID_VERSION) {} bool is_valid() const; TO_STRING_KV(K_(schema_id), K_(mode), K_(schema_version), "partition_cnt", partition_ids_.count()); uint64_t schema_id_; obrpc::ObCreateTableMode mode_; common::ObSArray partition_ids_; // Physical recovery, the list of partition_id existing in the baseline // SSTABLE int64_t schema_version_; // Physical recovery, the schema_version corresponding to the baseline }; struct ObServerZoneArg { OB_UNIS_VERSION(1); public: ObServerZoneArg() : server_(), zone_() {} // server can be invalid, zone can be empty bool is_valid() const { return true; } TO_STRING_KV(K_(server), K_(zone)); common::ObAddr server_; common::ObZone zone_; }; struct ObAdminReportReplicaArg : public ObServerZoneArg {}; struct ObAdminRecycleReplicaArg : public ObServerZoneArg {}; struct ObAdminRefreshSchemaArg : public ObServerZoneArg {}; struct ObAdminRefreshMemStatArg : public ObServerZoneArg {}; struct ObAdminClearLocationCacheArg : public ObServerZoneArg {}; struct ObRunJobArg : public ObServerZoneArg { OB_UNIS_VERSION(1); public: ObRunJobArg() : ObServerZoneArg(), job_() {} bool is_valid() const { return ObServerZoneArg::is_valid() && !job_.empty(); } TO_STRING_KV(K_(server), K_(zone), K_(job)); common::ObString job_; }; struct ObUpgradeJobArg { OB_UNIS_VERSION(1); public: enum Action { INVALID_ACTION, RUN_UPGRADE_JOB, STOP_UPGRADE_JOB }; public: ObUpgradeJobArg(); bool is_valid() const; int assign(const ObUpgradeJobArg& other); TO_STRING_KV(K_(action), K_(version)); public: Action action_; int64_t version_; }; struct ObAdminMergeArg { OB_UNIS_VERSION(1); public: enum Type { START_MERGE = 1, SUSPEND_MERGE = 2, RESUME_MERGE = 3, }; ObAdminMergeArg() : type_(START_MERGE), zone_() {} bool is_valid() const; TO_STRING_KV(K_(type), K_(zone)); Type type_; common::ObZone zone_; }; struct ObAdminClearRoottableArg { OB_UNIS_VERSION(1); public: ObAdminClearRoottableArg() : tenant_name_() {} // tenant_name be empty means all tenant bool is_valid() const { return true; } TO_STRING_KV(K_(tenant_name)); common::ObFixedLengthString tenant_name_; }; struct ObAdminSetConfigItem { OB_UNIS_VERSION(1); public: ObAdminSetConfigItem() : name_(), value_(), comment_(), zone_(), server_(), tenant_name_(), exec_tenant_id_(common::OB_SYS_TENANT_ID), tenant_ids_() {} TO_STRING_KV( K_(name), K_(value), K_(comment), K_(zone), K_(server), K_(tenant_name), K_(exec_tenant_id), K_(tenant_ids)); common::ObFixedLengthString name_; common::ObFixedLengthString value_; common::ObFixedLengthString comment_; common::ObZone zone_; common::ObAddr server_; common::ObFixedLengthString tenant_name_; uint64_t exec_tenant_id_; common::ObSArray tenant_ids_; }; struct ObAdminSetConfigArg { OB_UNIS_VERSION(1); public: ObAdminSetConfigArg() : items_(), is_inner_(false) {} ~ObAdminSetConfigArg() {} bool is_valid() const { return items_.count() > 0; } TO_STRING_KV(K_(items), K_(is_inner)); common::ObSArray items_; bool is_inner_; }; struct ObAdminLoadBaselineArg { OB_UNIS_VERSION(1); public: ObAdminLoadBaselineArg() : tenant_ids_(), sql_id_(), plan_hash_value_(common::OB_INVALID_ID), fixed_(false), enabled_(true) {} virtual ~ObAdminLoadBaselineArg() {} int push_tenant(uint64_t tenant_id) { return tenant_ids_.push_back(tenant_id); } TO_STRING_KV(K_(tenant_ids), K_(sql_id), K_(plan_hash_value), K_(fixed), K_(enabled)); common::ObSEArray tenant_ids_; common::ObString sql_id_; uint64_t plan_hash_value_; bool fixed_; bool enabled_; }; struct ObAdminFlushCacheArg { OB_UNIS_VERSION(1); public: ObAdminFlushCacheArg() : cache_type_(CACHE_TYPE_INVALID), is_fine_grained_(false) { } virtual ~ObAdminFlushCacheArg() {} bool is_valid() const { return cache_type_ > CACHE_TYPE_INVALID && cache_type_ < CACHE_TYPE_MAX; } int push_tenant(uint64_t tenant_id) { return tenant_ids_.push_back(tenant_id); } int push_database(uint64_t db_id) { return db_ids_.push_back(db_id); } TO_STRING_KV(K_(tenant_ids), K_(cache_type), K_(db_ids), K_(sql_id), K_(is_fine_grained)); common::ObSEArray tenant_ids_; ObCacheType cache_type_; common::ObSEArray db_ids_; common::ObString sql_id_; bool is_fine_grained_; }; struct ObAdminMigrateUnitArg { OB_UNIS_VERSION(1); public: ObAdminMigrateUnitArg() : unit_id_(0), is_cancel_(false), destination_() {} ~ObAdminMigrateUnitArg() {} bool is_valid() const { return common::OB_INVALID_ID != unit_id_ && (destination_.is_valid() || is_cancel_); } TO_STRING_KV(K_(unit_id), K_(is_cancel), K_(destination)); uint64_t unit_id_; bool is_cancel_; common::ObAddr destination_; }; struct ObAutoincSyncArg { OB_UNIS_VERSION(1); public: ObAutoincSyncArg() : tenant_id_(common::OB_INVALID_ID), table_id_(common::OB_INVALID_ID), column_id_(common::OB_INVALID_ID), sync_value_(0), table_part_num_(0), auto_increment_(0) {} TO_STRING_KV(K_(tenant_id), K_(table_id), K_(column_id), K_(sync_value), K_(table_part_num), K_(auto_increment)); uint64_t tenant_id_; uint64_t table_id_; uint64_t column_id_; uint64_t sync_value_; // TODO may need add first_part_num. As table_part_num not see usefull. // Not add first_part_num now. uint64_t table_part_num_; uint64_t auto_increment_; // only for sync table option auto_increment }; struct ObDropReplicaArg { OB_UNIS_VERSION(1); public: ObDropReplicaArg() : partition_key_(), member_() {} bool is_valid() const { return partition_key_.is_valid() && member_.is_valid(); } TO_STRING_KV(K_(partition_key), K_(member)); common::ObPartitionKey partition_key_; common::ObReplicaMember member_; }; struct ObUpdateIndexStatusArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObUpdateIndexStatusArg() : ObDDLArg(), index_table_id_(common::OB_INVALID_ID), status_(share::schema::INDEX_STATUS_MAX), create_mem_version_(0), convert_status_(true) {} bool is_valid() const; virtual bool is_allow_when_disable_ddl() const; virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(index_table_id), K_(status), K_(create_mem_version), K_(convert_status)); uint64_t index_table_id_; share::schema::ObIndexStatus status_; int64_t create_mem_version_; bool convert_status_; }; struct ObMergeFinishArg { OB_UNIS_VERSION(1); public: ObMergeFinishArg() : frozen_version_(0) {} bool is_valid() const { return server_.is_valid() && frozen_version_ > 0; } TO_STRING_KV(K_(server), K_(frozen_version)); common::ObAddr server_; int64_t frozen_version_; }; struct ObMergeErrorArg { OB_UNIS_VERSION(1); public: ObMergeErrorArg() : error_code_(0) {} bool is_valid() const; TO_STRING_KV(K_(partition_key), K_(server), K_(error_code)); common::ObPartitionKey partition_key_; common::ObAddr server_; int error_code_; }; struct ObAdminRebuildReplicaArg { OB_UNIS_VERSION(1); public: ObAdminRebuildReplicaArg() : key_(), server_() {} bool is_valid() const { return key_.is_valid() && server_.is_valid(); } TO_STRING_KV(K_(key), K_(server)); common::ObPartitionKey key_; common::ObAddr server_; }; struct ObDebugSyncActionArg { OB_UNIS_VERSION(1); public: ObDebugSyncActionArg() : reset_(false), clear_(false) {} bool is_valid() const { return reset_ || clear_ || action_.is_valid(); } TO_STRING_KV(K_(reset), K_(clear), K_(action)); bool reset_; bool clear_; common::ObDebugSyncAction action_; }; struct ObRootMajorFreezeArg { OB_UNIS_VERSION(1); public: ObRootMajorFreezeArg() : try_frozen_version_(0), launch_new_round_(false), ignore_server_list_(), svr_(), tenant_id_(common::OB_INVALID_TENANT_ID), force_launch_(false) {} inline void reset(); inline bool is_valid() const { return try_frozen_version_ >= 0; } TO_STRING_KV( K_(try_frozen_version), K_(launch_new_round), K(ignore_server_list_), K(svr_), K(tenant_id_), K_(force_launch)); int64_t try_frozen_version_; bool launch_new_round_; common::ObSArray ignore_server_list_; common::ObAddr svr_; int64_t tenant_id_; bool force_launch_; }; struct ObMinorFreezeArg { OB_UNIS_VERSION(1); public: ObMinorFreezeArg() {} void reset() { tenant_ids_.reset(); partition_key_.reset(); } bool is_valid() const { return true; } TO_STRING_KV(K_(tenant_ids), K_(partition_key)); common::ObSArray tenant_ids_; common::ObPartitionKey partition_key_; }; struct ObRootMinorFreezeArg { OB_UNIS_VERSION(2); public: ObRootMinorFreezeArg() {} void reset() { tenant_ids_.reset(); partition_key_.reset(); server_list_.reset(); zone_.reset(); } bool is_valid() const { return true; } TO_STRING_KV(K_(tenant_ids), K_(partition_key), K_(server_list), K_(zone)); common::ObSArray tenant_ids_; common::ObPartitionKey partition_key_; common::ObSArray server_list_; common::ObZone zone_; }; struct ObSyncPartitionTableFinishArg { OB_UNIS_VERSION(1); public: ObSyncPartitionTableFinishArg() : server_(), version_(0) {} inline bool is_valid() const { return server_.is_valid() && version_ > 0; } TO_STRING_KV(K_(server), K_(version)); common::ObAddr server_; int64_t version_; }; struct ObSyncPGPartitionMTFinishArg { OB_UNIS_VERSION(1); public: ObSyncPGPartitionMTFinishArg() : server_(), version_(0) {} inline bool is_valid() const { return server_.is_valid() && version_ > 0; } TO_STRING_KV(K_(server), K_(version)); common::ObAddr server_; int64_t version_; }; struct ObCheckDanglingReplicaFinishArg { OB_UNIS_VERSION(1); public: ObCheckDanglingReplicaFinishArg() : server_(), version_(0), dangling_count_(common::OB_INVALID_ID) {} inline bool is_valid() const { return server_.is_valid() && version_ > 0; } TO_STRING_KV(K_(server), K_(version), K_(dangling_count)); common::ObAddr server_; int64_t version_; int64_t dangling_count_; }; struct ObGetMemberListAndLeaderResult final { OB_UNIS_VERSION(1); public: ObGetMemberListAndLeaderResult() : member_list_(), leader_(), self_(), lower_list_(), replica_type_(common::REPLICA_TYPE_MAX), property_() {} void reset(); inline bool is_valid() const { return member_list_.count() > 0 && self_.is_valid() && common::REPLICA_TYPE_MAX != replica_type_ && property_.is_valid(); } int assign(const ObGetMemberListAndLeaderResult& other); TO_STRING_KV(K_(member_list), K_(leader), K_(self), K_(lower_list), K_(replica_type), K_(property)); common::ObSEArray member_list_; // copy won't fail common::ObAddr leader_; common::ObAddr self_; common::ObSEArray lower_list_; // Cascaded downstream // information common::ObReplicaType replica_type_; // The type of copy actually stored in the local copy common::ObReplicaProperty property_; }; struct ObMemberListAndLeaderArg { OB_UNIS_VERSION(1); public: ObMemberListAndLeaderArg() : member_list_(), leader_(), self_(), lower_list_(), replica_type_(common::REPLICA_TYPE_MAX), property_(), role_(common::INVALID_ROLE) {} void reset(); bool is_valid() const; bool check_leader_is_valid() const; int assign(const ObMemberListAndLeaderArg& other); TO_STRING_KV(K_(member_list), K_(leader), K_(self), K_(lower_list), K_(replica_type), K_(property), K_(role)); common::ObSEArray member_list_; // copy won't fail common::ObAddr leader_; common::ObAddr self_; common::ObSEArray lower_list_; // Cascaded downstream // information common::ObReplicaType replica_type_; // The type of copy actually stored in the local copy common::ObReplicaProperty property_; common::ObRole role_; }; struct ObBatchGetRoleArg { OB_UNIS_VERSION(1); public: ObBatchGetRoleArg() : keys_() {} virtual ~ObBatchGetRoleArg() {} void reset(); bool is_valid() const; TO_STRING_KV(K_(keys)); common::ObSArray keys_; }; struct ObBatchGetRoleResult { OB_UNIS_VERSION(1); public: ObBatchGetRoleResult() : results_() {} virtual ~ObBatchGetRoleResult() {} void reset(); bool is_valid() const; TO_STRING_KV(K_(results)); common::ObSArray results_; }; struct ObSwitchLeaderListArg { OB_UNIS_VERSION(1); public: ObSwitchLeaderListArg() : partition_key_list_(), leader_addr_() {} ~ObSwitchLeaderListArg() {} inline void reset() { partition_key_list_.reset(); leader_addr_.reset(); } bool is_valid() const { return partition_key_list_.count() > 0 && leader_addr_.is_valid(); } TO_STRING_KV(K_(leader_addr), K_(partition_key_list)); ; common::ObSArray partition_key_list_; common::ObAddr leader_addr_; }; struct ObCheckFlashbackInfoArg { OB_UNIS_VERSION(1); public: ObCheckFlashbackInfoArg() : min_weak_read_timestamp_(common::OB_INVALID_TIMESTAMP) {} ~ObCheckFlashbackInfoArg() {} int assign(const ObCheckFlashbackInfoArg& other); bool is_valid() const { return min_weak_read_timestamp_ != common::OB_INVALID_TIMESTAMP; } TO_STRING_KV(K_(min_weak_read_timestamp)) int64_t min_weak_read_timestamp_; }; struct ObCheckFlashbackInfoResult { OB_UNIS_VERSION(1); public: ObCheckFlashbackInfoResult() : addr_(), pkey_(), result_(false), switchover_timestamp_(common::OB_INVALID_TIMESTAMP), ret_code_(common::OB_SUCCESS) {} ~ObCheckFlashbackInfoResult() {} int assign(const ObCheckFlashbackInfoResult& other); TO_STRING_KV(K_(addr), K_(pkey), K_(result), K_(switchover_timestamp), K_(ret_code)) common::ObAddr addr_; // Addr of current obs common::ObPartitionKey pkey_; // Unfinished partition_key bool result_; // Current obs query result int64_t switchover_timestamp_; // The current switchover_timestap of the bottom layer to prevent the wrong return // packet int ret_code_; }; struct ObGetPartitionCountResult { OB_UNIS_VERSION(1); public: ObGetPartitionCountResult() : partition_count_(0) {} void reset() { partition_count_ = 0; } TO_STRING_KV(K_(partition_count)); int64_t partition_count_; }; inline void Int64::reset() { v_ = common::OB_INVALID_ID; } inline void ObCreatePartitionArg::reset() { zone_.reset(); partition_key_.reset(); schema_version_ = 0; memstore_version_ = 0; replica_num_ = 0; member_list_.reset(); leader_.reset(); lease_start_ = 0; logonly_replica_num_ = 0; backup_replica_num_ = 0; readonly_replica_num_ = 0; replica_type_ = common::REPLICA_TYPE_MAX; last_submit_timestamp_ = 0; restore_ = share::REPLICA_NOT_RESTORE; table_schemas_.reset(); source_partition_key_.reset(); frozen_timestamp_ = 0; non_paxos_replica_num_ = 0; last_replay_log_id_ = 0; pg_key_.reset(); replica_property_.reset(); split_info_.reset(); ignore_member_list_ = false; } inline void ObCreatePartitionStorageArg::reset() { rgkey_.reset(); partition_key_.reset(); schema_version_ = 0; memstore_version_ = 0; last_submit_timestamp_ = 0; restore_ = share::REPLICA_NOT_RESTORE; table_schemas_.reset(); } inline void ObCreatePartitionBatchArg::reset() { args_.reset(); } inline void ObMajorFreezeArg::reset() { frozen_version_ = 0; schema_version_ = 0; frozen_timestamp_ = 0; } inline void ObMajorFreezeArg::reuse() { frozen_version_ = 0; schema_version_ = 0; frozen_timestamp_ = 0; } inline void ObSetParentArg::reset() { partition_key_.reset(); parent_addr_.reset(); } inline void ObSwitchLeaderArg::reset() { partition_key_.reset(); leader_addr_.reset(); } inline void ObRootMajorFreezeArg::reset() { try_frozen_version_ = 0; launch_new_round_ = false; force_launch_ = false; } struct ObCreateUserDefinedFunctionArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateUserDefinedFunctionArg() : ObDDLArg(), udf_() {} virtual ~ObCreateUserDefinedFunctionArg() {} bool is_valid() const { return !udf_.get_name_str().empty(); } TO_STRING_KV(K_(udf)); share::schema::ObUDF udf_; }; struct ObDropUserDefinedFunctionArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropUserDefinedFunctionArg() : tenant_id_(common::OB_INVALID_ID), name_(), if_exist_(false) {} virtual ~ObDropUserDefinedFunctionArg() {} bool is_valid() const { return !name_.empty(); } virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(name)); uint64_t tenant_id_; common::ObString name_; bool if_exist_; }; struct ObCreateOutlineArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateOutlineArg() : ObDDLArg(), or_replace_(false), outline_info_(), db_name_() {} virtual ~ObCreateOutlineArg() {} bool is_valid() const; TO_STRING_KV(K_(or_replace), K_(outline_info), K_(db_name)); bool or_replace_; share::schema::ObOutlineInfo outline_info_; common::ObString db_name_; }; struct ObAlterOutlineArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum AlterOutlineOptions { ADD_OUTLINE_CONTENT = 1, ADD_CONCURRENT_LIMIT, MAX_OPTION }; ObAlterOutlineArg() : ObDDLArg(), alter_outline_info_(), db_name_() {} virtual ~ObAlterOutlineArg() {} bool is_valid() const { return (!db_name_.empty() && !alter_outline_info_.get_signature_str().empty() && (!alter_outline_info_.get_outline_content_str().empty() || alter_outline_info_.has_outline_params())); } TO_STRING_KV(K_(alter_outline_info), K_(db_name)); share::schema::ObAlterOutlineInfo alter_outline_info_; common::ObString db_name_; }; struct ObDropOutlineArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropOutlineArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), db_name_(), outline_name_() {} virtual ~ObDropOutlineArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(db_name), K_(outline_name)); uint64_t tenant_id_; common::ObString db_name_; common::ObString outline_name_; }; struct ObCreateDbLinkArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObCreateDbLinkArg() : ObDDLArg(), dblink_info_() {} virtual ~ObCreateDbLinkArg() {} bool is_valid() const; TO_STRING_KV(K_(dblink_info)); share::schema::ObDbLinkInfo dblink_info_; }; struct ObDropDbLinkArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDropDbLinkArg() : ObDDLArg(), tenant_id_(common::OB_INVALID_ID), dblink_name_() {} virtual ~ObDropDbLinkArg() {} bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(dblink_name)); uint64_t tenant_id_; common::ObString dblink_name_; }; struct ObUseDatabaseArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObUseDatabaseArg() : ObDDLArg() {} }; struct ObFetchAliveServerArg { OB_UNIS_VERSION(1); public: ObFetchAliveServerArg() : cluster_id_(0) {} TO_STRING_KV(K_(cluster_id)); bool is_valid() const { return cluster_id_ >= 0; } int64_t cluster_id_; }; struct ObFetchAliveServerResult { OB_UNIS_VERSION(1); public: TO_STRING_KV(K_(active_server_list)); bool is_valid() const { return !active_server_list_.empty(); } ObServerList active_server_list_; ObServerList inactive_server_list_; }; struct ObLoadBaselineArg { OB_UNIS_VERSION(1); public: ObLoadBaselineArg() : is_all_tenant_(false), tenant_id_(common::OB_INVALID_TENANT_ID), sql_id_(), plan_hash_value_(common::OB_INVALID_ID), fixed_(false), enabled_(false) {} virtual ~ObLoadBaselineArg() {} TO_STRING_KV(K(is_all_tenant_), K_(tenant_id), K_(sql_id), K_(plan_hash_value), K_(fixed), K_(enabled)); bool is_all_tenant_; uint64_t tenant_id_; common::ObString sql_id_; uint64_t plan_hash_value_; bool fixed_; bool enabled_; }; struct ObFlushCacheArg { OB_UNIS_VERSION(1); public: ObFlushCacheArg() : is_all_tenant_(false), tenant_id_(common::OB_INVALID_TENANT_ID), cache_type_(CACHE_TYPE_INVALID), is_fine_grained_(false){}; virtual ~ObFlushCacheArg() {} bool is_valid() const { return cache_type_ > CACHE_TYPE_INVALID && cache_type_ < CACHE_TYPE_MAX; } int push_database(uint64_t db_id) { return db_ids_.push_back(db_id); } TO_STRING_KV(K(is_all_tenant_), K_(tenant_id), K_(cache_type), K_(db_ids), K_(sql_id), K_(is_fine_grained)); bool is_all_tenant_; uint64_t tenant_id_; ObCacheType cache_type_; common::ObSEArray db_ids_; common::ObString sql_id_; bool is_fine_grained_; }; struct ObGetAllSchemaArg { OB_UNIS_VERSION(1); public: ObGetAllSchemaArg() : schema_version_(common::OB_INVALID_VERSION) {} TO_STRING_KV(K_(schema_version), K_(tenant_name)); int64_t schema_version_; common::ObString tenant_name_; }; struct ObAdminSetTPArg : public ObServerZoneArg { OB_UNIS_VERSION(1); public: ObAdminSetTPArg() : event_no_(0), occur_(0), trigger_freq_(1), error_code_(0) {} inline bool is_valid() const { return (error_code_ <= 0 && (trigger_freq_ >= 0)); } TO_STRING_KV(K_(event_no), K_(event_name), K_(occur), K_(trigger_freq), K_(error_code), K_(server), K_(zone)); int64_t event_no_; // tracepoint no common::ObString event_name_; // tracepoint name int64_t occur_; // number of occurrences int64_t trigger_freq_; // trigger frequency int64_t error_code_; // error code to return }; struct ObCancelTaskArg : public ObServerZoneArg { OB_UNIS_VERSION(2); public: ObCancelTaskArg() : task_id_() {} TO_STRING_KV(K_(task_id)); share::ObTaskId task_id_; }; struct ObReportSingleReplicaArg { OB_UNIS_VERSION(1); public: ObReportSingleReplicaArg() : partition_key_() {} bool is_valid() const { return partition_key_.is_valid(); } TO_STRING_KV(K_(partition_key)); common::ObPartitionKey partition_key_; }; struct ObSetDiskValidArg { OB_UNIS_VERSION(1); public: ObSetDiskValidArg() {} bool is_valid() const { return true; } }; struct ObAdminClearBalanceTaskArg { OB_UNIS_VERSION(1); public: enum TaskType { AUTO = 0, MANUAL, ALL, MAX_TYPE }; ObAdminClearBalanceTaskArg() : tenant_ids_(), type_(ALL), zone_names_() {} ~ObAdminClearBalanceTaskArg() {} TO_STRING_KV(K_(tenant_ids), K_(type), K_(zone_names)); common::ObSEArray tenant_ids_; TaskType type_; common::ObSEArray zone_names_; }; class ObMCLogInfo { OB_UNIS_VERSION(1); public: ObMCLogInfo() : log_id_(common::OB_INVALID_ID), timestamp_(common::OB_INVALID_TIMESTAMP) {} ~ObMCLogInfo(){}; bool is_valid() const { return common::OB_INVALID_ID != log_id_ && common::OB_INVALID_TIMESTAMP != timestamp_; } public: uint64_t log_id_; int64_t timestamp_; TO_STRING_KV(K_(log_id), K_(timestamp)); }; struct ObChangeMemberArg { OB_UNIS_VERSION(1); public: ObChangeMemberArg() : partition_key_(), member_(), quorum_(), switch_epoch_(common::OB_INVALID_VERSION) {} common::ObPartitionKey partition_key_; common::ObMember member_; int64_t quorum_; int64_t switch_epoch_; TO_STRING_KV(K_(partition_key), K_(member), K_(quorum), K_(switch_epoch)); }; struct ObChangeMemberCtx { OB_UNIS_VERSION(1); public: ObChangeMemberCtx() : partition_key_(), ret_value_(common::OB_SUCCESS), log_info_() {} common::ObPartitionKey partition_key_; int32_t ret_value_; ObMCLogInfo log_info_; TO_STRING_KV(K_(partition_key), K_(ret_value), K_(log_info)); }; typedef common::ObSArray ObChangeMemberArgs; typedef common::ObSArray ObChangeMemberCtxs; struct ObChangeMemberCtxsWrapper { OB_UNIS_VERSION(1); public: ObChangeMemberCtxsWrapper() : result_code_(common::OB_SUCCESS), ctxs_() {} int32_t result_code_; ObChangeMemberCtxs ctxs_; TO_STRING_KV(K_(result_code), K_(ctxs)); }; struct ObMemberMajorSSTableCheckArg { OB_UNIS_VERSION(1); public: ObMemberMajorSSTableCheckArg() : pkey_(), table_ids_() {} TO_STRING_KV(K_(pkey), K_(table_ids)); common::ObPartitionKey pkey_; common::ObSArray table_ids_; }; struct ObForceSwitchILogFileArg { OB_UNIS_VERSION(1); public: ObForceSwitchILogFileArg() : force_(true) {} ~ObForceSwitchILogFileArg() {} DECLARE_TO_STRING; bool force_; }; struct ObForceSetAllAsSingleReplicaArg { OB_UNIS_VERSION(1); public: ObForceSetAllAsSingleReplicaArg() : force_(true) {} ~ObForceSetAllAsSingleReplicaArg() {} DECLARE_TO_STRING; bool force_; }; struct ObForceSetServerListArg { OB_UNIS_VERSION(1); public: ObForceSetServerListArg() : server_list_(), replica_num_(0) {} ~ObForceSetServerListArg() {} DECLARE_TO_STRING; obrpc::ObServerList server_list_; int64_t replica_num_; }; struct ObForceCreateSysTableArg { OB_UNIS_VERSION(1); public: ObForceCreateSysTableArg() : tenant_id_(common::OB_INVALID_TENANT_ID), table_id_(common::OB_INVALID_ID), last_replay_log_id_(common::OB_INVALID_ID) {} ~ObForceCreateSysTableArg() {} bool is_valid() const; DECLARE_TO_STRING; uint64_t tenant_id_; uint64_t table_id_; uint64_t last_replay_log_id_; }; struct ObForceSetLocalityArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObForceSetLocalityArg() : ObDDLArg(), locality_() {} virtual ~ObForceSetLocalityArg() {} bool is_valid() const; int assign(const ObForceSetLocalityArg& other); virtual bool is_allow_when_upgrade() const { return true; } common::ObString locality_; TO_STRING_KV(K_(exec_tenant_id), K_(locality)); }; struct ObRootSplitPartitionArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObRootSplitPartitionArg() : ObDDLArg(), table_id_(common::OB_INVALID_ID) {} virtual ~ObRootSplitPartitionArg() {} bool is_valid() const { return table_id_ != common::OB_INVALID_ID; } int assign(const ObRootSplitPartitionArg& other); virtual bool is_allow_when_upgrade() const { return true; } DECLARE_TO_STRING; uint64_t table_id_; }; struct ObSplitPartitionArg { OB_UNIS_VERSION(1); public: ObSplitPartitionArg() : split_info_() {} ~ObSplitPartitionArg() {} TO_STRING_KV(K_(split_info)); bool is_valid() const { return split_info_.is_valid(); } void reset() { split_info_.reset(); } public: share::ObSplitPartition split_info_; }; struct ObSplitPartitionResult { OB_UNIS_VERSION(1); public: ObSplitPartitionResult() : results_() {} ~ObSplitPartitionResult() {} void reset() { results_.reuse(); } common::ObSArray& get_result() { return results_; } const common::ObSArray& get_result() const { return results_; } TO_STRING_KV(K_(results)); private: common::ObSArray results_; }; struct ObSplitPartitionBatchArg { OB_UNIS_VERSION(1); public: ObSplitPartitionBatchArg() {} ~ObSplitPartitionBatchArg() {} bool is_valid() const; int assign(const ObSplitPartitionBatchArg& other); void reset() { return split_info_.reset(); } DECLARE_TO_STRING; share::ObSplitPartition split_info_; private: DISALLOW_COPY_AND_ASSIGN(ObSplitPartitionBatchArg); }; struct ObSplitPartitionBatchRes { OB_UNIS_VERSION(1); public: ObSplitPartitionBatchRes() : ret_list_() {} ~ObSplitPartitionBatchRes() {} inline void reset() { ret_list_.reset(); } int assign(const ObSplitPartitionBatchRes& other); inline void reuse(); DECLARE_TO_STRING; // response includes all rets common::ObSArray ret_list_; private: DISALLOW_COPY_AND_ASSIGN(ObSplitPartitionBatchRes); }; struct ObQueryMaxDecidedTransVersionRequest { OB_UNIS_VERSION(1); public: ObQueryMaxDecidedTransVersionRequest() : partition_array_(), last_max_decided_trans_version_(0) {} ~ObQueryMaxDecidedTransVersionRequest() {} void reset() { partition_array_.reset(); last_max_decided_trans_version_ = 0; } common::ObPartitionArray partition_array_; int64_t last_max_decided_trans_version_; TO_STRING_KV(K(partition_array_), K_(last_max_decided_trans_version)); }; struct ObQueryMaxDecidedTransVersionResponse { OB_UNIS_VERSION(1); public: ObQueryMaxDecidedTransVersionResponse() : ret_value_(common::OB_SUCCESS), trans_version_(0) {} ~ObQueryMaxDecidedTransVersionResponse() {} void reset() { ret_value_ = common::OB_SUCCESS; trans_version_ = 0; } int ret_value_; int64_t trans_version_; common::ObPartitionKey pkey_; TO_STRING_KV(K(ret_value_), K(trans_version_), K_(pkey)); }; struct ObQueryIsValidMemberRequest { OB_UNIS_VERSION(1); public: ObQueryIsValidMemberRequest() : self_addr_(), partition_array_() {} ~ObQueryIsValidMemberRequest() {} void reset() { self_addr_.reset(); partition_array_.reset(); } common::ObAddr self_addr_; common::ObPartitionArray partition_array_; TO_STRING_KV(K(self_addr_), K(partition_array_)); }; struct ObQueryIsValidMemberResponse { OB_UNIS_VERSION(1); public: ObQueryIsValidMemberResponse() : ret_value_(common::OB_SUCCESS), partition_array_(), candidates_status_(), ret_array_() {} ~ObQueryIsValidMemberResponse() {} void reset() { ret_value_ = common::OB_SUCCESS; partition_array_.reset(); candidates_status_.reset(); ret_array_.reset(); } int ret_value_; common::ObPartitionArray partition_array_; common::ObSEArray candidates_status_; common::ObSEArray ret_array_; TO_STRING_KV(K(ret_value_), K(partition_array_), K(candidates_status_), K(ret_array_)); }; struct ObQueryMaxFlushedILogIdRequest { OB_UNIS_VERSION(1); public: ObQueryMaxFlushedILogIdRequest() : partition_array_() {} ~ObQueryMaxFlushedILogIdRequest() {} void reset() { partition_array_.reset(); } common::ObPartitionArray partition_array_; TO_STRING_KV(K(partition_array_)); }; struct ObQueryMaxFlushedILogIdResponse { OB_UNIS_VERSION(1); public: ObQueryMaxFlushedILogIdResponse() : err_code_(common::OB_SUCCESS), partition_array_(), max_flushed_ilog_ids_() {} ~ObQueryMaxFlushedILogIdResponse() {} void reset() { err_code_ = common::OB_SUCCESS; partition_array_.reset(); max_flushed_ilog_ids_.reset(); } int err_code_; common::ObPartitionArray partition_array_; common::ObSEArray max_flushed_ilog_ids_; TO_STRING_KV(K_(err_code), K_(partition_array), K_(max_flushed_ilog_ids)); }; struct ObBootstrapArg { OB_UNIS_VERSION(1); public: ObBootstrapArg() : server_list_(), cluster_type_(common::PRIMARY_CLUSTER), initial_frozen_version_(0), initial_schema_version_(0), primary_cluster_id_(common::OB_INVALID_ID), primary_rs_list_(), freeze_schemas_(), frozen_status_() {} ~ObBootstrapArg() {} TO_STRING_KV(K_(server_list), K_(cluster_type), K_(initial_frozen_version), K_(initial_schema_version), K_(primary_cluster_id), K_(primary_rs_list), K_(freeze_schemas), K_(frozen_status)); int assign(const ObBootstrapArg& arg); ObServerInfoList server_list_; common::ObClusterType cluster_type_; int64_t initial_frozen_version_; int64_t initial_schema_version_; int64_t primary_cluster_id_; common::ObSArray primary_rs_list_; common::ObSArray freeze_schemas_; common::ObSArray frozen_status_; }; struct ObBatchStartElectionArg { OB_UNIS_VERSION(1); public: enum SwitchType { INVALID_TYPE = -1, SWITCHOVER, FAILOVER, }; ObBatchStartElectionArg() : pkeys_(), lease_start_time_(0), leader_(), member_list_(), switch_timestamp_(0), switch_type_(INVALID_TYPE), quorum_(-1), trace_id_() {} ~ObBatchStartElectionArg() {} int add_partition_key(const common::ObPartitionKey& pkey); const ObPkeyArray& get_pkey_array() const { return pkeys_; } int set_leader(const common::ObAddr& leader) { leader_ = leader; return common::OB_SUCCESS; } const common::ObAddr get_leader() const { return leader_; } void set_switch_timestamp(const int64_t switch_timestamp) { switch_timestamp_ = switch_timestamp; } int64_t get_switch_timestamp() const { return switch_timestamp_; } int set_member_list(const common::ObMemberList& member_list) { return member_list_.deep_copy(member_list); } const common::ObMemberList& get_member_list() const { return member_list_; } void set_quorum(const int64_t quorum) { quorum_ = quorum; } int64_t get_quorum() const { return quorum_; } int assign(const ObBatchStartElectionArg& other); int64_t count() const { return pkeys_.count(); } bool reach_concurrency_limit() const { return pkeys_.count() >= MAX_COUNT; } bool has_task() const { return pkeys_.count() > 0; } void set_lease_timestamp() { lease_start_time_ = common::ObTimeUtility::current_time(); } int64_t get_lease_start() const { return lease_start_time_; } void set_trace_id(const common::ObCurTraceId::TraceId& trace_id) { trace_id_ = trace_id; } void reset(); bool is_valid() const; void set_switch_type(const SwitchType& switch_type) { switch_type_ = switch_type; } SwitchType get_switch_type() const { return switch_type_; } TO_STRING_KV(K_(trace_id), "count", pkeys_.count(), K_(member_list), K_(lease_start_time), K_(leader), K_(switch_timestamp), K_(switch_type), K_(pkeys), K_(quorum)); public: static bool is_valid_switch_type(const int32_t switch_type) { return (switch_type >= SWITCHOVER && switch_type <= FAILOVER); } ObPkeyArray pkeys_; private: int64_t lease_start_time_; common::ObAddr leader_; common::ObMemberList member_list_; int64_t switch_timestamp_; SwitchType switch_type_; int64_t quorum_; // In the failover process, there may be a single copy, so quorum needs to be specified by rs common::ObCurTraceId::TraceId trace_id_; private: DISALLOW_COPY_AND_ASSIGN(ObBatchStartElectionArg); }; struct ObBatchFlashbackArg { OB_UNIS_VERSION(1); public: static const int64_t MAX_COUNT = 128; ObBatchFlashbackArg() : switchover_timestamp_(0), flashback_to_ts_(0), leader_(), pkeys_(), flashback_from_ts_(0), frozen_timestamp_(0), is_logical_flashback_(false), query_end_time_(0), schema_version_(0) {} ~ObBatchFlashbackArg() {} void set_leader(const common::ObAddr& addr) { leader_ = addr; } void reset(); void set_switchover_timestamp(const int64_t switchover_timestamp) { switchover_timestamp_ = switchover_timestamp; } void set_flashback_ts(const int64_t flashback_from_ts, const int64_t flashback_to_ts) { flashback_from_ts_ = flashback_from_ts; flashback_to_ts_ = flashback_to_ts; } void set_frozen_timestamp(const int64_t frozen_timestamp) { frozen_timestamp_ = frozen_timestamp; } int64_t get_frozen_timestamp() const { return frozen_timestamp_; } void set_is_logical_flashback(const bool is_logical_flashback) { is_logical_flashback_ = is_logical_flashback; } bool is_logical_flashback() const { return is_logical_flashback_; } void set_query_end_time(const int64_t query_end_time) { query_end_time_ = query_end_time; } int64_t get_query_end_time() const { return query_end_time_; } void set_schema_version(const int64_t schema_version) { schema_version_ = schema_version; } int64_t get_schema_version() const { return schema_version_; } bool reach_concurrency_limit() const { return pkeys_.count() >= MAX_COUNT; } int add_pkey(const common::ObPartitionKey& pkey); const ObPkeyArray& get_pkey_array() const { return pkeys_; } common::ObAddr get_server() const { return leader_; } int64_t get_flashback_to_ts() const { return flashback_to_ts_; } int64_t get_flashback_from_ts() const { return flashback_from_ts_; } int64_t get_switchover_timestamp() const { return switchover_timestamp_; } bool is_valid() const; bool has_task() const { return pkeys_.count() > 0; } TO_STRING_KV(K_(switchover_timestamp), K_(flashback_to_ts), K_(flashback_from_ts), K_(leader), K_(is_logical_flashback), K_(pkeys), K_(frozen_timestamp), K_(query_end_time), K_(schema_version)); public: int64_t switchover_timestamp_; int64_t flashback_to_ts_; common::ObAddr leader_; ObPkeyArray pkeys_; int64_t flashback_from_ts_; int64_t frozen_timestamp_; bool is_logical_flashback_; // failover use int64_t query_end_time_; int64_t schema_version_; }; struct ObAlterClusterInfoArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum OpType { INVALID_TYPE = -1, SWITCH_TO_STANDBY = 0, SWITCH_TO_PRIMARY = 1, FAILOVER_TO_PRIMARY = 2, CONVERT_TO_STANDBY = 3, INTACT_FAILOVER = 4, SET_PROTECTION_MODE = 5, UPDATE_PROTECTION_LEVEL = 6, UPDATE_SYNC_STANDBY_PROTECTION_LEVEL = 7, }; ObAlterClusterInfoArg() : op_type_(INVALID_TYPE), mode_(common::MAXIMUM_PERFORMANCE_MODE), is_force_(false), level_(common::MAXIMUM_PERFORMANCE_LEVEL) {} TO_STRING_KV(K_(op_type), K_(ddl_stmt_str), K_(mode), K_(level), K_(is_force)); int assign(ObAlterClusterInfoArg& arg); ~ObAlterClusterInfoArg() {} const char* get_alter_type_str() const { const char* cstr = "invalid"; switch (op_type_) { case SWITCH_TO_STANDBY: cstr = "switchover to physical standby"; break; case SWITCH_TO_PRIMARY: cstr = "switchover to primary"; break; case FAILOVER_TO_PRIMARY: cstr = "failover to primary"; break; case CONVERT_TO_STANDBY: cstr = "convert to physical standby"; break; case INTACT_FAILOVER: cstr = "intact failover to primary"; break; case SET_PROTECTION_MODE: cstr = "set cluster protection mode"; break; case UPDATE_PROTECTION_LEVEL: cstr = "update protection level in maximum availability mode"; break; case UPDATE_SYNC_STANDBY_PROTECTION_LEVEL: cstr = "update sync standby protection level"; break; default: cstr = "invalid"; break; } return cstr; } public: OpType op_type_; common::ObProtectionMode mode_; bool is_force_; common::ObProtectionLevel level_; }; struct ObAdminClusterArg { OB_UNIS_VERSION(1); public: enum AlterClusterType { INVALID_TYPE = -1, ADD_CLUSTER = 0, REMOVE_CLUSTER, ENABLE_CLUSTER, DISABLE_CLUSTER, ALTER_CLUSTER, }; public: ObAdminClusterArg() : cluster_name_(), cluster_id_(common::OB_INVALID_ID), alter_type_(INVALID_TYPE), is_force_(false), ddl_stmt_str_(), rootservice_list_(), redo_transport_options_() {} ~ObAdminClusterArg() {} void set_cluster_name(const common::ObString& cluster_name) { cluster_name_ = cluster_name; } void set_cluster_id(const int64_t cluster_id) { cluster_id_ = cluster_id; } void set_alter_cluster_type(const AlterClusterType type) { alter_type_ = type; } void set_is_force(const bool is_force) { is_force_ = is_force; } bool is_valid() const { return !cluster_name_.empty() && common::OB_INVALID_ID != cluster_id_ && INVALID_TYPE != alter_type_; } void set_ddl_stmt_str(const common::ObString& ddl_stmt_str) { ddl_stmt_str_ = ddl_stmt_str; } int set_rootservice_list(const common::ObIArray& rs_list) { return rootservice_list_.assign(rs_list); } void set_redo_transport_options_str(const common::ObString& redo_transport_options_str) { redo_transport_options_ = redo_transport_options_str; } const char* get_cluster_admin_type_cstr() const { const char* cstr = "invalid"; switch (alter_type_) { case ADD_CLUSTER: cstr = "add cluster"; break; case REMOVE_CLUSTER: cstr = "remove cluster"; break; case ENABLE_CLUSTER: cstr = "enable cluster synchronization"; break; case DISABLE_CLUSTER: cstr = "disable cluster synchronization"; break; case ALTER_CLUSTER: cstr = "alter cluster"; break; default: cstr = "invalid"; break; } return cstr; } TO_STRING_KV(K_(cluster_name), K_(cluster_id), K_(alter_type), K_(is_force), K_(ddl_stmt_str), K_(rootservice_list), K_(redo_transport_options)); common::ObString cluster_name_; int64_t cluster_id_; AlterClusterType alter_type_; bool is_force_; common::ObString ddl_stmt_str_; common::ObSArray rootservice_list_; common::ObString redo_transport_options_; }; struct ObClusterActionVerifyArg { OB_UNIS_VERSION(1); public: enum VerifyType { INVALID_TYPE = -1, ADD_CLUSTER_VERIFY = 0, }; public: ObClusterActionVerifyArg() : verify_type_(INVALID_TYPE) {} ~ObClusterActionVerifyArg() {} void set_verify_type(const VerifyType type) { verify_type_ = type; } bool is_valid() const { return INVALID_TYPE != verify_type_; } TO_STRING_KV(K_(verify_type)); VerifyType verify_type_; }; struct ObDDLNopOpreatorArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObDDLNopOpreatorArg() : schema_operation_() {} ~ObDDLNopOpreatorArg() {} public: share::schema::ObSchemaOperation schema_operation_; bool is_valid() const { return schema_operation_.is_valid(); } virtual bool is_allow_when_upgrade() const { return true; } void reset() { schema_operation_.reset(); } TO_STRING_KV(K_(schema_operation)); private: DISALLOW_COPY_AND_ASSIGN(ObDDLNopOpreatorArg); }; // end for ddl arg ////////////////////////////////////////////////// struct ObEstPartArgElement { ObEstPartArgElement() : index_id_(common::OB_INVALID_ID), range_columns_count_(0) {} // Essentially, we can use ObIArray here // For compatibility reason, we still use ObSimpleBatch common::ObSimpleBatch batch_; common::ObQueryFlag scan_flag_; int64_t index_id_; int64_t range_columns_count_; TO_STRING_KV(K(scan_flag_), K(index_id_), K(batch_), K(range_columns_count_)); int64_t get_serialize_size(void) const; int serialize(char* buf, const int64_t buf_len, int64_t& pos) const; int deserialize(common::ObIAllocator& allocator, const char* buf, const int64_t data_len, int64_t& pos); }; struct ObEstPartArg { // Deserialization use common::ObArenaAllocator allocator_; //***** Parameters involved in obtaining master table information common::ObPartitionKey pkey_; int64_t schema_version_; common::ObSEArray column_ids_; // Estimated table row length parameter common::ObSEArray partition_keys_; // Estimate the number of rows in the entire table parameter ObEstPartArgElement scan_param_; //***** end // Get statistics specific variables for each index common::ObSEArray index_params_; // best estimation partition key for each index common::ObSEArray index_pkeys_; ObEstPartArg() : allocator_(common::ObModIds::OB_SQL_QUERY_RANGE), pkey_(), schema_version_(0), column_ids_(), partition_keys_(), scan_param_(), index_params_(), index_pkeys_() {} ~ObEstPartArg() {} bool is_valid_table_pkey() const { return pkey_.is_valid(); } TO_STRING_KV(K_(column_ids), K_(pkey), K_(schema_version), K_(partition_keys), K_(scan_param), K_(index_params), K_(index_pkeys)); OB_UNIS_VERSION(1); }; struct ObEstPartResElement { int64_t logical_row_count_; int64_t physical_row_count_; /** * @brief reliable_ * storage estimation is not successfully called, * we use ndv to estimate row count in the following */ bool reliable_; common::ObSEArray est_records_; ObEstPartResElement() { reset(); } void reset() { logical_row_count_ = common::OB_INVALID_COUNT; physical_row_count_ = common::OB_INVALID_COUNT; reliable_ = false; est_records_.reset(); } TO_STRING_KV(K(logical_row_count_), K(physical_row_count_), K(reliable_), K(est_records_)); OB_UNIS_VERSION(1); }; struct ObEstPartRowCountSizeRes { int64_t row_count_; int64_t part_size_; double avg_row_size_; /** * @brief reliable_ * reliable = true if the table is empty, * we will use default row count in the following */ bool reliable_; ObEstPartRowCountSizeRes() { reset(); } void reset() { row_count_ = common::OB_INVALID_COUNT; part_size_ = common::OB_INVALID_COUNT; avg_row_size_ = -1; reliable_ = false; } TO_STRING_KV(K(row_count_), K(part_size_), K(avg_row_size_), K(reliable_)); OB_UNIS_VERSION(1); }; struct ObEstPartRes { ObEstPartRowCountSizeRes part_rowcount_size_res_; common::ObSEArray index_param_res_; ObEstPartRes() : part_rowcount_size_res_(), index_param_res_() {} TO_STRING_KV(K(part_rowcount_size_res_), K(index_param_res_)); OB_UNIS_VERSION(1); }; struct TenantServerUnitConfig { public: TenantServerUnitConfig() : tenant_id_(common::OB_INVALID_ID), compat_mode_(share::ObWorker::CompatMode::INVALID), unit_config_(), replica_type_(common::ObReplicaType::REPLICA_TYPE_MAX), if_not_grant_(false), is_delete_(false) {} int init(const uint64_t tenant_id, const share::ObWorker::CompatMode compat_mode, const share::ObUnitConfig& unit_config, const common::ObReplicaType replica_type, const bool if_not_grant, const bool is_delete); uint64_t tenant_id_; share::ObWorker::CompatMode compat_mode_; share::ObUnitConfig unit_config_; common::ObReplicaType replica_type_; bool if_not_grant_; bool is_delete_; bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(unit_config), K_(compat_mode), K_(replica_type), K_(if_not_grant), K_(is_delete)); OB_UNIS_VERSION(1); }; struct ObGetWRSArg { OB_UNIS_VERSION(1); public: enum Scope { INVALID_RANGE = 0, INNER_TABLE, USER_TABLE, ALL_TABLE }; TO_STRING_KV(K_(tenant_id), K_(scope), K_(need_filter)); bool is_valid() const; int64_t tenant_id_; Scope scope_; // The machine-readable timestamp can be calculated separately for the timestamp of the system table or // user table, or collectively calculated together bool need_filter_; ObGetWRSArg() : tenant_id_(common::OB_INVALID_TENANT_ID), scope_(ALL_TABLE), // Statistics of all types of tables by default need_filter_(false) // Unreadable partitions are not filtered by default {} explicit ObGetWRSArg(const int64_t tenant_id) : tenant_id_(tenant_id), scope_(ALL_TABLE), // Statistics of all types of tables by default need_filter_(false) // Unreadable partitions are not filtered by default {} }; struct ObGetWRSResult { OB_UNIS_VERSION(1); public: ObGetWRSResult() : self_addr_(), err_code_(0), replica_wrs_info_list_() {} void reset() { self_addr_.reset(); err_code_ = 0; replica_wrs_info_list_.reset(); } public: common::ObAddr self_addr_; int err_code_; // error code // According to the ObGetWRSArg::need_filter_ field to determine whether to filter the copies with invalid // machine-readable timestamps share::ObReplicaWrsInfoList replica_wrs_info_list_; // Standby machine-readable timestamp of each copy of this server TO_STRING_KV(K_(err_code), K_(self_addr), "replica_count", replica_wrs_info_list_.count(), K_(replica_wrs_info_list)); }; struct ObTenantSchemaVersions { OB_UNIS_VERSION(1); public: ObTenantSchemaVersions() : tenant_schema_versions_() {} common::ObSArray tenant_schema_versions_; int add(const int64_t tenant_id, const int64_t schema_version); void reset() { return tenant_schema_versions_.reset(); } bool is_valid() const { return 0 < tenant_schema_versions_.count(); } int assign(const ObTenantSchemaVersions& arg) { int ret = common::OB_SUCCESS; if (OB_FAIL(tenant_schema_versions_.assign(arg.tenant_schema_versions_))) { SHARE_LOG(WARN, "failed to assign tenant schema version", KR(ret), K(arg)); } return ret; } TO_STRING_KV(K_(tenant_schema_versions)); }; struct ObGetSchemaArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObGetSchemaArg() : reserve_(0), ignore_fail_(false) {} virtual bool is_allow_when_upgrade() const { return true; } int64_t reserve_; bool ignore_fail_; }; struct TenantIdAndStats { OB_UNIS_VERSION(1); public: TenantIdAndStats() : tenant_id_(common::OB_INVALID_TENANT_ID), refreshed_schema_version_(0), ddl_lag_(0), min_sys_table_scn_(0), min_user_table_scn_(0) {} TenantIdAndStats(const uint64_t tenant_id, const int64_t refreshed_schema_version, const int64_t ddl_lag, const int64_t min_sys_table_scn, const int64_t min_user_table_scn) : tenant_id_(tenant_id), refreshed_schema_version_(refreshed_schema_version), ddl_lag_(ddl_lag), min_sys_table_scn_(min_sys_table_scn), min_user_table_scn_(min_user_table_scn) {} TO_STRING_KV(K_(tenant_id), K_(refreshed_schema_version), K_(ddl_lag), K_(min_sys_table_scn), K_(min_user_table_scn)); void reset() { tenant_id_ = common::OB_INVALID_TENANT_ID; refreshed_schema_version_ = 0; ddl_lag_ = 0; min_sys_table_scn_ = 0; min_user_table_scn_ = 0; } uint64_t tenant_id_; int64_t refreshed_schema_version_; int64_t ddl_lag_; int64_t min_sys_table_scn_; int64_t min_user_table_scn_; }; struct ObClusterTenantStats { OB_UNIS_VERSION(1); public: void reset() { return tenant_stats_array_.reset(); } int assign(const ObClusterTenantStats& other) { int ret = common::OB_SUCCESS; if (OB_FAIL(tenant_stats_array_.assign(other.tenant_stats_array_))) { SHARE_LOG(WARN, "fail to assign partition ids", K(ret)); } return ret; } TO_STRING_KV(K_(tenant_stats_array)); common::ObSArray tenant_stats_array_; }; struct ObFinishSchemaSplitArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFinishSchemaSplitArg() : tenant_id_(common::OB_INVALID_TENANT_ID), type_(rootserver::ObRsJobType::JOB_TYPE_SCHEMA_SPLIT_V2) {} virtual ~ObFinishSchemaSplitArg() {} bool is_valid() const; int assign(const ObFinishSchemaSplitArg& other); virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(tenant_id), K_(type)); public: uint64_t tenant_id_; rootserver::ObRsJobType type_; }; struct ObBroadcastSchemaArg { OB_UNIS_VERSION(1); public: ObBroadcastSchemaArg() : tenant_id_(common::OB_INVALID_TENANT_ID), schema_version_(common::OB_INVALID_VERSION) {} void reset(); public: uint64_t tenant_id_; int64_t schema_version_; TO_STRING_KV(K_(tenant_id), K_(schema_version)); }; struct ObCheckMergeFinishArg { OB_UNIS_VERSION(1); public: ObCheckMergeFinishArg() : frozen_version_(0) {} bool is_valid() const; public: int64_t frozen_version_; TO_STRING_KV(K_(frozen_version)); }; struct ObGetRecycleSchemaVersionsArg { OB_UNIS_VERSION(1); public: ObGetRecycleSchemaVersionsArg() : tenant_ids_() {} virtual ~ObGetRecycleSchemaVersionsArg() {} bool is_valid() const; void reset(); int assign(const ObGetRecycleSchemaVersionsArg& other); public: common::ObSArray tenant_ids_; TO_STRING_KV(K_(tenant_ids)); }; struct ObGetRecycleSchemaVersionsResult { OB_UNIS_VERSION(1); public: ObGetRecycleSchemaVersionsResult() : recycle_schema_versions_() {} virtual ~ObGetRecycleSchemaVersionsResult() {} bool is_valid() const; void reset(); int assign(const ObGetRecycleSchemaVersionsResult& other); public: common::ObSArray recycle_schema_versions_; TO_STRING_KV(K_(recycle_schema_versions)); }; struct ObGetClusterInfoArg { OB_UNIS_VERSION(1); public: ObGetClusterInfoArg() : need_check_sync_(false), max_primary_schema_version_(common::OB_INVALID_VERSION), primary_schema_versions_(), cluster_version_(common::OB_INVALID_ID), standby_became_primary_scn_(common::OB_INVALID_VERSION) {} bool is_valid() const; void reset(); TO_STRING_KV(K_(need_check_sync), K_(max_primary_schema_version), K_(primary_schema_versions), K_(cluster_version), K_(standby_became_primary_scn)); public: bool need_check_sync_; int64_t max_primary_schema_version_; // The largest schema version of the main library system tenant ObTenantSchemaVersions primary_schema_versions_; // The schema version of all tenants of the main library, used to // check user_tenant_schema_sync uint64_t cluster_version_; int64_t standby_became_primary_scn_; }; struct ObCheckAddStandbyArg { OB_UNIS_VERSION(1); public: ObCheckAddStandbyArg() : cluster_version_(common::OB_INVALID_ID) {} bool is_valid() const { return common::OB_INVALID_ID != cluster_version_; } void reset() { cluster_version_ = common::OB_INVALID_ID; } TO_STRING_KV(K_(cluster_version)); public: uint64_t cluster_version_; }; class ObHaGtsPingRequest { OB_UNIS_VERSION(1); public: ObHaGtsPingRequest() : gts_id_(common::OB_INVALID_ID), req_id_(common::OB_INVALID_ID), epoch_id_(common::OB_INVALID_TIMESTAMP), request_ts_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsPingRequest() {} public: void reset() { gts_id_ = common::OB_INVALID_ID; req_id_ = common::OB_INVALID_ID; epoch_id_ = common::OB_INVALID_TIMESTAMP; request_ts_ = common::OB_INVALID_TIMESTAMP; } bool is_valid() const { return common::is_valid_gts_id(gts_id_) && common::OB_INVALID_ID != req_id_ && epoch_id_ > 0 && request_ts_ > 0; } void set(const uint64_t gts_id, const uint64_t req_id, const int64_t epoch_id, const int64_t request_ts) { gts_id_ = gts_id; req_id_ = req_id; epoch_id_ = epoch_id; request_ts_ = request_ts; } uint64_t get_gts_id() const { return gts_id_; } uint64_t get_req_id() const { return req_id_; } int64_t get_epoch_id() const { return epoch_id_; } int64_t get_request_ts() const { return request_ts_; } TO_STRING_KV(K(gts_id_), K(req_id_), K(epoch_id_), K(request_ts_)); private: uint64_t gts_id_; uint64_t req_id_; int64_t epoch_id_; int64_t request_ts_; }; class ObHaGtsPingResponse { OB_UNIS_VERSION(1); public: ObHaGtsPingResponse() : gts_id_(common::OB_INVALID_ID), req_id_(common::OB_INVALID_ID), epoch_id_(common::OB_INVALID_TIMESTAMP), response_ts_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsPingResponse() {} public: void reset() { gts_id_ = common::OB_INVALID_ID; req_id_ = common::OB_INVALID_ID; epoch_id_ = common::OB_INVALID_TIMESTAMP; response_ts_ = common::OB_INVALID_TIMESTAMP; } bool is_valid() const { return common::is_valid_gts_id(gts_id_) && common::OB_INVALID_ID != req_id_ && epoch_id_ > 0 && response_ts_ > 0; } void set(const uint64_t gts_id, const uint64_t req_id, const int64_t epoch_id, const int64_t response_ts) { gts_id_ = gts_id; req_id_ = req_id; epoch_id_ = epoch_id; response_ts_ = response_ts; } uint64_t get_gts_id() const { return gts_id_; } uint64_t get_req_id() const { return req_id_; } int64_t get_epoch_id() const { return epoch_id_; } int64_t get_response_ts() const { return response_ts_; } TO_STRING_KV(K(gts_id_), K(req_id_), K(epoch_id_), K(response_ts_)); private: uint64_t gts_id_; uint64_t req_id_; int64_t epoch_id_; int64_t response_ts_; }; class ObHaGtsGetRequest { OB_UNIS_VERSION(1); public: ObHaGtsGetRequest() : gts_id_(common::OB_INVALID_ID), self_addr_(), tenant_id_(common::OB_INVALID_TENANT_ID), srr_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsGetRequest() {} public: void reset() { gts_id_ = common::OB_INVALID_ID; self_addr_.reset(); tenant_id_ = common::OB_INVALID_TENANT_ID; srr_.reset(); } bool is_valid() const { return common::is_valid_gts_id(gts_id_) && self_addr_.is_valid() && srr_.is_valid(); } void set(const uint64_t gts_id, const common::ObAddr& self_addr, const uint64_t tenant_id, const transaction::MonotonicTs srr) { gts_id_ = gts_id; self_addr_ = self_addr; tenant_id_ = tenant_id; srr_ = srr; } uint64_t get_gts_id() const { return gts_id_; } const common::ObAddr& get_self_addr() const { return self_addr_; } uint64_t get_tenant_id() const { return tenant_id_; } transaction::MonotonicTs get_srr() const { return srr_; } TO_STRING_KV(K(gts_id_), K(self_addr_), K(tenant_id_), K(srr_)); private: uint64_t gts_id_; common::ObAddr self_addr_; // TODO: To be deleted uint64_t tenant_id_; transaction::MonotonicTs srr_; }; class ObHaGtsGetResponse { OB_UNIS_VERSION(1); public: ObHaGtsGetResponse() : gts_id_(common::OB_INVALID_ID), tenant_id_(common::OB_INVALID_TENANT_ID), srr_(common::OB_INVALID_TIMESTAMP), gts_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsGetResponse() {} public: void reset() { gts_id_ = common::OB_INVALID_ID; tenant_id_ = common::OB_INVALID_TENANT_ID; srr_.reset(); gts_ = common::OB_INVALID_TIMESTAMP; } bool is_valid() const { return common::is_valid_gts_id(gts_id_) && srr_.is_valid() && gts_ > 0; } void set(const uint64_t gts_id, const uint64_t tenant_id, const transaction::MonotonicTs srr, const int64_t gts) { gts_id_ = gts_id; tenant_id_ = tenant_id; srr_ = srr; gts_ = gts; } int64_t get_gts_id() const { return gts_id_; } uint64_t get_tenant_id() const { return tenant_id_; } transaction::MonotonicTs get_srr() const { return srr_; } int64_t get_gts() const { return gts_; } TO_STRING_KV(K(gts_id_), K(tenant_id_), K(srr_), K(gts_)); private: uint64_t gts_id_; // TODO: To be deleted uint64_t tenant_id_; transaction::MonotonicTs srr_; int64_t gts_; }; class ObHaGtsHeartbeat { OB_UNIS_VERSION(1); public: ObHaGtsHeartbeat() : gts_id_(common::OB_INVALID_ID), addr_() {} ~ObHaGtsHeartbeat() {} public: bool is_valid() const { return common::is_valid_gts_id(gts_id_) && addr_.is_valid(); } void set(const uint64_t gts_id, const common::ObAddr& addr) { gts_id_ = gts_id; addr_ = addr; } uint64_t get_gts_id() const { return gts_id_; } const common::ObAddr& get_addr() const { return addr_; } TO_STRING_KV(K(gts_id_), K(addr_)); private: uint64_t gts_id_; common::ObAddr addr_; }; class ObHaGtsUpdateMetaRequest { OB_UNIS_VERSION(1); public: ObHaGtsUpdateMetaRequest() : gts_id_(common::OB_INVALID_ID), epoch_id_(common::OB_INVALID_TIMESTAMP), member_list_(), local_ts_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsUpdateMetaRequest() {} public: bool is_valid() const { return common::is_valid_gts_id(gts_id_) && epoch_id_ > 0 && member_list_.get_member_number() > 0 && member_list_.get_member_number() <= 3 && local_ts_ > 0; } void set( const uint64_t gts_id, const int64_t epoch_id, const common::ObMemberList& member_list, const int64_t local_ts) { gts_id_ = gts_id; epoch_id_ = epoch_id; member_list_ = member_list; local_ts_ = local_ts; } uint64_t get_gts_id() const { return gts_id_; } int64_t get_epoch_id() const { return epoch_id_; } const common::ObMemberList& get_member_list() const { return member_list_; } int64_t get_local_ts() const { return local_ts_; } TO_STRING_KV(K(gts_id_), K(epoch_id_), K(member_list_), K(local_ts_)); private: uint64_t gts_id_; int64_t epoch_id_; common::ObMemberList member_list_; int64_t local_ts_; }; class ObHaGtsUpdateMetaResponse { OB_UNIS_VERSION(1); public: ObHaGtsUpdateMetaResponse() : local_ts_(common::OB_INVALID_TIMESTAMP) {} ~ObHaGtsUpdateMetaResponse() {} public: bool is_valid() const { return local_ts_ > 0; } void set(const int64_t local_ts) { local_ts_ = local_ts; } int64_t get_local_ts() const { return local_ts_; } TO_STRING_KV(K(local_ts_)); private: int64_t local_ts_; }; class ObHaGtsChangeMemberRequest { OB_UNIS_VERSION(1); public: ObHaGtsChangeMemberRequest() : gts_id_(common::OB_INVALID_ID), offline_replica_() {} ~ObHaGtsChangeMemberRequest() {} public: bool is_valid() const { return common::is_valid_gts_id(gts_id_) && offline_replica_.is_valid(); } void set(const uint64_t gts_id, const common::ObAddr& offline_replica) { gts_id_ = gts_id; offline_replica_ = offline_replica; } uint64_t get_gts_id() const { return gts_id_; } const common::ObAddr& get_offline_replica() const { return offline_replica_; } TO_STRING_KV(K(gts_id_), K(offline_replica_)); private: uint64_t gts_id_; common::ObAddr offline_replica_; }; class ObHaGtsChangeMemberResponse { OB_UNIS_VERSION(1); public: ObHaGtsChangeMemberResponse() : ret_value_(common::OB_SUCCESS) {} ~ObHaGtsChangeMemberResponse() {} public: void set(const int ret_value) { ret_value_ = ret_value; } int get_ret_value() const { return ret_value_; } TO_STRING_KV(K(ret_value_)); private: int ret_value_; }; struct ObClusterInfoArg { OB_UNIS_VERSION(1); public: ObClusterInfoArg() : cluster_info_(), server_status_(share::OBSERVER_INVALID_STATUS), sync_cluster_ids_(), redo_options_() {} bool is_valid() const; TO_STRING_KV(K_(cluster_info), K_(server_status), K_(sync_cluster_ids), K_(redo_options)); int assign(const ObClusterInfoArg& other); public: share::ObClusterInfo cluster_info_; share::ServerServiceStatus server_status_; common::ObSEArray sync_cluster_ids_; share::ObRedoTransportOption redo_options_; }; struct ObSchemaSnapshotArg { OB_UNIS_VERSION(1); public: ObSchemaSnapshotArg() : schema_version_(0), frozen_version_(0) {} bool is_valid() const { return schema_version_ >= 0 && frozen_version_ >= 0; } void reset() { schema_version_ = 0; } TO_STRING_KV(K_(schema_version), K_(frozen_version)); public: int64_t schema_version_; int64_t frozen_version_; }; // The maximum size of the RPC packet is 64M, and it can store about 2W schemas. The streaming interface is not used for // the time being struct ObSchemaSnapshotRes { OB_UNIS_VERSION(1); public: ObSchemaSnapshotRes(); bool is_valid() const; void reset(); TO_STRING_KV(K_(schema_version), K_(frozen_version), "table_count", table_schemas_.count(), "tenant_count", tenant_schemas_.count(), "user_count", user_infos_.count(), "freeze_schema", freeze_schemas_, K_(tenant_flashback_scn), K_(failover_timestamp), K_(frozen_status), K_(cluster_name)); int assign(const ObSchemaSnapshotRes& res); public: int64_t schema_version_; int64_t frozen_version_; common::ObSArray table_schemas_; common::ObSArray tenant_schemas_; common::ObSArray user_infos_; common::ObSArray db_privs_; common::ObSArray table_privs_; common::ObSArray freeze_schemas_; // Record the schema_version corresponding to the // frozen_version_ + 2 version; int64_t failover_timestamp_; common::ObSArray tenant_flashback_scn_; common::ObSArray frozen_status_; bool sys_schema_changed_; // Used to verify that the primary and standby cluster names are consistent common::ObFixedLengthString cluster_name_; }; struct ObRegistClusterArg { OB_UNIS_VERSION(1); public: ObRegistClusterArg() : cluster_name_(), cluster_id_(common::OB_INVALID_ID), pre_regist_(false), cluster_addr_() {} bool is_valid() const { return cluster_id_ > 0 && !cluster_name_.empty(); } public: common::ObString cluster_name_; uint64_t cluster_id_; bool pre_regist_; share::ObClusterAddr cluster_addr_; TO_STRING_KV(K_(cluster_id), K_(cluster_name), K_(pre_regist), K_(cluster_addr)); }; struct ObAlterTableResArg { OB_UNIS_VERSION(1); public: ObAlterTableResArg() : schema_type_(share::schema::OB_MAX_SCHEMA), schema_id_(common::OB_INVALID_ID), schema_version_(common::OB_INVALID_VERSION) {} ObAlterTableResArg( const share::schema::ObSchemaType schema_type, const uint64_t schema_id, const int64_t schema_version) : schema_type_(schema_type), schema_id_(schema_id), schema_version_(schema_version) {} void reset(); public: TO_STRING_KV(K_(schema_type), K_(schema_id), K_(schema_version)); share::schema::ObSchemaType schema_type_; uint64_t schema_id_; int64_t schema_version_; }; struct ObAlterTableRes { OB_UNIS_VERSION(1); public: ObAlterTableRes() : index_table_id_(common::OB_INVALID_ID), constriant_id_(common::OB_INVALID_ID), schema_version_(common::OB_INVALID_VERSION), res_arg_array_() {} void reset(); public: TO_STRING_KV(K_(index_table_id), K_(constriant_id), K_(schema_version), K_(res_arg_array)); uint64_t index_table_id_; uint64_t constriant_id_; int64_t schema_version_; common::ObSArray res_arg_array_; }; struct ObRegistClusterRes { OB_UNIS_VERSION(1); public: ObRegistClusterRes() : cluster_idx_(common::OB_INVALID_INDEX) {} bool is_valid() const { return cluster_idx_ >= 0; } int set_login_name(const char* login_name) { return login_name_.assign(login_name); } int set_login_passwd(const char* login_passwd) { return login_passwd_.assign(login_passwd); } int set_primary_cluster(const share::ObClusterAddr& primary_cluster); void reset(); public: TO_STRING_KV(K_(cluster_idx), K_(login_name)); int64_t cluster_idx_; share::ObClusterInfo::UserNameString login_name_; share::ObClusterInfo::PassWdString login_passwd_; share::ObClusterAddr primary_cluster_; }; struct ObStandbyHeartBeatRes { OB_UNIS_VERSION(1); public: ObStandbyHeartBeatRes() : primary_addr_(), standby_addr_(), primary_schema_info_(), protection_mode_(common::MAXIMUM_PROTECTION_MODE), tenant_schema_vers_() {} ~ObStandbyHeartBeatRes() {} void set_refreshed_schema_version(const int64_t refreshed_schema_version) { primary_schema_info_.primary_broadcasted_schema_version_ = refreshed_schema_version; } void set_next_schema_version(const int64_t next_schema_version) { primary_schema_info_.primary_next_schema_version_ = next_schema_version; } int set_primary_addr(const share::ObClusterAddr& primary_addr); int set_standby_addr(const share::ObClusterAddr& standby_addr); void set_protection_mode(common::ObProtectionMode mode) { protection_mode_ = mode; } void reset() { primary_addr_.reset(); standby_addr_.reset(); primary_schema_info_.reset(); tenant_schema_vers_.reset(); protection_mode_ = common::MAXIMUM_PROTECTION_MODE; } public: TO_STRING_KV(K_(primary_addr), K_(standby_addr), K_(primary_schema_info), K_(protection_mode)); share::ObClusterAddr primary_addr_; share::ObClusterAddr standby_addr_; share::schema::ObPrimarySchemaInfo primary_schema_info_; common::ObProtectionMode protection_mode_; ObTenantSchemaVersions tenant_schema_vers_; }; struct ObGetSwitchoverStatusRes { OB_UNIS_VERSION(1); public: ObGetSwitchoverStatusRes() : switchover_status_(share::ObClusterInfo::I_INVALID), switchover_info_() {} ~ObGetSwitchoverStatusRes() {} public: TO_STRING_KV(K_(switchover_status), K_(switchover_info)); share::ObClusterInfo::InMemorySwitchOverStatus switchover_status_; share::ObClusterSwitchoverInfoWrap switchover_info_; }; struct ObGetTenantSchemaVersionArg { OB_UNIS_VERSION(1); public: ObGetTenantSchemaVersionArg() : tenant_id_(common::OB_INVALID_TENANT_ID) {} bool is_valid() const { return common::OB_INVALID_TENANT_ID != tenant_id_; } TO_STRING_KV(K_(tenant_id)); uint64_t tenant_id_; }; struct ObGetTenantSchemaVersionResult { OB_UNIS_VERSION(1); public: ObGetTenantSchemaVersionResult() : schema_version_(common::OB_INVALID_VERSION) {} bool is_valid() const { return schema_version_ > 0; } TO_STRING_KV(K_(schema_version)); int64_t schema_version_; }; struct ObFinishReplayArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObFinishReplayArg() : schema_version_(common::OB_INVALID_VERSION) {} bool is_valid() const { return schema_version_ > 0; } virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(schema_version)); int64_t schema_version_; }; struct ObTenantMemoryArg { OB_UNIS_VERSION(1); public: ObTenantMemoryArg() : tenant_id_(0), memory_size_(0), refresh_interval_(0) {} bool is_valid() const { return tenant_id_ > 0 && memory_size_ > 0 && refresh_interval_ >= 0; } TO_STRING_KV(K_(tenant_id), K_(memory_size)); int64_t tenant_id_; int64_t memory_size_; int64_t refresh_interval_; }; struct ObProfileDDLArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObProfileDDLArg() : ObDDLArg(), schema_(), ddl_type_(), is_cascade_(false) {} virtual bool is_allow_when_upgrade() const { return share::schema::OB_DDL_DROP_PROFILE == ddl_type_; } share::schema::ObProfileSchema schema_; share::schema::ObSchemaOperationType ddl_type_; bool is_cascade_; TO_STRING_KV(K_(schema), K_(ddl_type), K_(is_cascade)); }; struct ObCheckServerEmptyArg { OB_UNIS_VERSION(1); public: enum Mode { BOOTSTRAP, ADD_SERVER }; ObCheckServerEmptyArg() : mode_(BOOTSTRAP) {} TO_STRING_KV(K_(mode)); Mode mode_; }; struct ObForceDropSchemaArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObForceDropSchemaArg() : ObDDLArg(), recycle_schema_version_(common::OB_INVALID_VERSION), schema_id_(common::OB_INVALID_ID), partition_ids_(), type_(share::schema::OB_MAX_SCHEMA), subpartition_ids_() {} virtual ~ObForceDropSchemaArg() {} bool is_valid() const; int assign(const ObForceDropSchemaArg& other); virtual bool is_allow_when_upgrade() const { return true; } TO_STRING_KV(K_(exec_tenant_id), K_(schema_id), K_(type), "partition_cnt", partition_ids_.count(), "subpartition_cnt", subpartition_ids_.count()); int64_t recycle_schema_version_; // The backed up schema_version is used for verification uint64_t schema_id_; // table_id/tablegroup_id common::ObSArray partition_ids_; // Non-empty means to delete the partition (including the delayed deletion // object of the second-level partition table and the first-level // partition) share::schema::ObSchemaType type_; common::ObSArray subpartition_ids_; // Non-empty means delete subpartition (only non-templated secondary // partition table) }; struct ObArchiveLogArg { OB_UNIS_VERSION(1); public: ObArchiveLogArg() : enable_(true) {} TO_STRING_KV(K_(enable)); bool enable_; }; struct ObBackupDatabaseArg { OB_UNIS_VERSION(1); public: ObBackupDatabaseArg(); bool is_valid() const; TO_STRING_KV(K_(tenant_id), K_(is_incremental), K_(passwd), K_(encryption_mode)); uint64_t tenant_id_; bool is_incremental_; share::ObBackupEncryptionMode::EncryptionMode encryption_mode_; common::ObFixedLengthString passwd_; }; struct ObTableTTLArg { OB_UNIS_VERSION(1); public: ObTableTTLArg(); int assign(const ObTableTTLArg& other); TO_STRING_KV(K_(cmd_code)); int64_t cmd_code_; }; struct ObBackupManageArg { OB_UNIS_VERSION(1); public: enum Type { CANCEL_BACKUP = 0, SUSPEND_BACKUP = 1, RESUME_BACKUP = 2, // DELETE_EXPIRED_BACKUP = 3, DELETE_BACKUP = 4, VALIDATE_DATABASE = 5, VALIDATE_BACKUPSET = 6, CANCEL_VALIDATE = 7, DELETE_OBSOLETE_BACKUP = 8, CANCEL_BACKUP_BACKUPSET = 9, CANCEL_DELETE_BACKUP = 10, DELETE_BACKUPPIECE = 11, DELETE_OBSOLETE_BACKUP_BACKUP = 12, CANCEL_BACKUP_BACKUPPIECE = 13, DELETE_BACKUPROUND = 14, CANCEL_ALL_BACKUP_FORCE = 15, MAX_TYPE }; ObBackupManageArg() : tenant_id_(OB_INVALID_TENANT_ID), type_(MAX_TYPE), value_(0), copy_id_(0) {} TO_STRING_KV(K_(type), K_(value), K_(copy_id)); uint64_t tenant_id_; Type type_; int64_t value_; int64_t copy_id_; }; struct ObBackupBackupsetArg { OB_UNIS_VERSION(1); public: ObBackupBackupsetArg(); bool is_valid() const; int assign(const ObBackupBackupsetArg& o); TO_STRING_KV(K_(tenant_id), K_(backup_set_id), K_(tenant_name), K_(backup_backup_dest), K_(max_backup_times)); uint64_t tenant_id_; int64_t backup_set_id_; common::ObString tenant_name_; char backup_backup_dest_[share::OB_MAX_BACKUP_DEST_LENGTH]; int64_t max_backup_times_; }; struct ObBackupArchiveLogArg { OB_UNIS_VERSION(1); public: ObBackupArchiveLogArg() : enable_(false) {} int assign(const ObBackupArchiveLogArg& o); TO_STRING_KV(K_(enable)); bool enable_; }; struct ObBackupBackupPieceArg { OB_UNIS_VERSION(1); public: ObBackupBackupPieceArg(); ~ObBackupBackupPieceArg() {} bool is_valid() const { return OB_INVALID_ID != tenant_id_ && piece_id_ != -1; } int assign(const ObBackupBackupPieceArg& o); TO_STRING_KV(K_(tenant_id), K_(piece_id), K_(max_backup_times), K_(backup_all), K_(backup_backup_dest)); uint64_t tenant_id_; int64_t piece_id_; common::ObString tenant_name_; char backup_backup_dest_[share::OB_MAX_BACKUP_DEST_LENGTH]; int64_t max_backup_times_; bool backup_all_; bool with_active_piece_; }; struct ObCheckStandbyCanAccessArg { OB_UNIS_VERSION(1); public: ObCheckStandbyCanAccessArg() : failover_epoch_(common::OB_INVALID_VERSION), last_merged_version_(common::OB_INVALID_VERSION), cluster_status_(), tenant_flashback_scn_() {} ~ObCheckStandbyCanAccessArg() {} TO_STRING_KV(K_(failover_epoch), K_(last_merged_version), K_(cluster_status), K_(tenant_flashback_scn)); bool is_valid() const { return common::OB_INVALID_VERSION != failover_epoch_ && common::OB_INVALID_VERSION != last_merged_version_ && 0 < cluster_status_.count() && 0 < tenant_flashback_scn_.count(); } int64_t failover_epoch_; int64_t last_merged_version_; common::ObSArray cluster_status_; common::ObSArray tenant_flashback_scn_; }; struct ObPhysicalFlashbackResultArg { OB_UNIS_VERSION(1); public: ObPhysicalFlashbackResultArg() : min_version_(common::OB_INVALID_VERSION), max_version_(common::OB_INVALID_VERSION), enable_result_(false) {} ~ObPhysicalFlashbackResultArg() {} TO_STRING_KV(K_(min_version), K_(max_version), K_(enable_result)); int64_t min_version_; int64_t max_version_; bool enable_result_; }; struct ObCheckPhysicalFlashbackArg { OB_UNIS_VERSION(1); public: ObCheckPhysicalFlashbackArg() : merged_version_(common::OB_INVALID_VERSION), flashback_scn_(common::OB_INVALID_VERSION) {} ~ObCheckPhysicalFlashbackArg() {} TO_STRING_KV(K_(merged_version), K_(flashback_scn)); public: int64_t merged_version_; int64_t flashback_scn_; }; struct CheckLeaderRpcIndex { OB_UNIS_VERSION(1); public: int64_t switchover_timestamp_; // Switch logo int64_t epoch_; //(switchover_timestamp, epoch) uniquely identifies a statistical information during a switching // process int64_t tenant_id_; int64_t ml_pk_index_; // Position the coordinates of pkey int64_t pkey_info_start_index_; // Position the coordinates of pkey CheckLeaderRpcIndex() : switchover_timestamp_(0), epoch_(0), tenant_id_(common::OB_INVALID_TENANT_ID), ml_pk_index_(0), pkey_info_start_index_(0){}; ~CheckLeaderRpcIndex() { reset(); } bool is_valid() const; void reset(); TO_STRING_KV(K_(switchover_timestamp), K_(epoch), K_(tenant_id), K_(ml_pk_index), K_(pkey_info_start_index)); }; struct ObBatchWriteCutdataClogArg { OB_UNIS_VERSION(1); public: ObBatchWriteCutdataClogArg() { reset(); } ~ObBatchWriteCutdataClogArg() {} void build_arg(const int64_t schema_version, const int64_t switchover_timestamp, const int64_t flashback_ts, const int64_t query_end_time) { schema_version_ = schema_version; switchover_timestamp_ = switchover_timestamp; flashback_ts_ = flashback_ts; query_end_time_ = query_end_time; } void set_switchover_timestamp(const int64_t switchover_timestamp) { switchover_timestamp_ = switchover_timestamp; } void set_flashback_ts(const int64_t flashback_ts) { flashback_ts_ = flashback_ts; } void set_schema_version(const int64_t schema_version) { schema_version_ = schema_version; } int64_t get_schema_version() const { return schema_version_; } void set_query_end_time(const int64_t query_end_time) { query_end_time_ = query_end_time; } int64_t get_query_end_time() const { return query_end_time_; } bool reach_concurrency_limit() const { return pkeys_.count() >= MAX_COUNT; } int add_pkey(const common::ObPartitionKey& pkey); const ObPkeyArray& get_pkey_array() const { return pkeys_; } int64_t get_flashback_ts() const { return flashback_ts_; } int64_t get_switchover_timestamp() const { return switchover_timestamp_; } bool is_valid() const; bool has_task() const { return pkeys_.count() > 0; } void reset(); void set_trace_id(const common::ObCurTraceId::TraceId& trace_id) { trace_id_ = trace_id; } TO_STRING_KV( K_(switchover_timestamp), K_(pkeys), K_(flashback_ts), K_(schema_version), K_(trace_id), K_(query_end_time)); public: static const int64_t MAX_COUNT = 1024; int64_t switchover_timestamp_; ObPkeyArray pkeys_; int64_t flashback_ts_; int64_t schema_version_; CheckLeaderRpcIndex index_; common::ObCurTraceId::TraceId trace_id_; int64_t query_end_time_; }; struct ObBatchCheckLeaderArg { OB_UNIS_VERSION(1); public: ObPkeyArray pkeys_; CheckLeaderRpcIndex index_; common::ObCurTraceId::TraceId trace_id_; // TODO: set trace to facilitate tracking ObBatchCheckLeaderArg() { reset(); } ~ObBatchCheckLeaderArg() {} bool is_valid() const; void reset(); bool reach_concurrency_limit() const { return pkeys_.count() >= MAX_COUNT; } bool has_task() const { return pkeys_.count() > 0; } void set_trace_id(const common::ObCurTraceId::TraceId& trace_id) { trace_id_ = trace_id; } TO_STRING_KV(K_(index), K_(pkeys)); }; struct ObBatchCheckRes { OB_UNIS_VERSION(1); public: common::ObSArray results_; // Corresponding to the above pkeys--, true means there is a master, false means no // master CheckLeaderRpcIndex index_; // Same value as ObBatchCheckLeaderArg ObBatchCheckRes() { reset(); } ~ObBatchCheckRes() {} bool is_valid() const; void reset(); TO_STRING_KV(K_(index), K_(results)); }; struct ObRebuildIndexInRestoreArg { OB_UNIS_VERSION(1); public: ObRebuildIndexInRestoreArg() : tenant_id_(common::OB_INVALID_TENANT_ID) {} ~ObRebuildIndexInRestoreArg() {} bool is_valid() const { return common::OB_INVALID_TENANT_ID != tenant_id_; } void reset() { tenant_id_ = common::OB_INVALID_TENANT_ID; } public: uint64_t tenant_id_; TO_STRING_KV(K_(tenant_id)); }; struct ObUpdateTableSchemaVersionArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum Action { INVALID = 0, UPDATE_SYS_ALL_INNER_TABLE, UPDATE_SYS_INNER_TABLE, UPDATE_SYS_TABLE_IN_TENANT_SPACE, }; ObUpdateTableSchemaVersionArg() : tenant_id_(common::OB_INVALID_TENANT_ID), table_id_(OB_INVALID_ID), schema_version_(share::OB_INVALID_SCHEMA_VERSION), action_(Action::INVALID) {} ~ObUpdateTableSchemaVersionArg() { reset(); } bool is_valid() const; virtual bool is_allow_when_upgrade() const; TO_STRING_KV(K_(tenant_id), K_(table_id), K_(schema_version)); void reset(); void init(const int64_t tenant_id, const int64_t table_id, const int64_t schema_version, const bool is_replay_schema, const Action action); int assign(const ObUpdateTableSchemaVersionArg &other); public: uint64_t tenant_id_; uint64_t table_id_; int64_t schema_version_; Action action_; }; struct ObRestoreModifySchemaArg : public ObDDLArg { OB_UNIS_VERSION(1); public: enum TYPE { INVALID_TYPE, RESET_DATABASE_PRIMARY_ZONE, RESET_TABLEGROUP_PRIMARY_ZONE, RESET_TABLEGROUP_LOCALITY, RESET_TABLEGROUP_PREVIOUS_LOCALITY, RESET_TABLE_PRIMARY_ZONE, RESET_TABLE_LOCALITY, RESET_TABLE_PREVIOUS_LOCALITY, MAX_TYPE, }; public: ObRestoreModifySchemaArg() : type_(INVALID_TYPE), schema_id_(common::OB_INVALID_ID) {} ~ObRestoreModifySchemaArg() {} bool is_valid() const; TO_STRING_KV(K_(type), K_(schema_id)); public: TYPE type_; uint64_t schema_id_; }; struct ObCheckDeploymentModeArg { OB_UNIS_VERSION(1); public: ObCheckDeploymentModeArg() : single_zone_deployment_on_(false) {} TO_STRING_KV(K_(single_zone_deployment_on)); bool single_zone_deployment_on_; }; struct ObPreProcessServerArg { OB_UNIS_VERSION(1); public: ObPreProcessServerArg() : server_(), rescue_server_() {} TO_STRING_KV(K_(server)); bool is_valid() const { return server_.is_valid() && rescue_server_.is_valid(); } int init(const common::ObAddr& server, const common::ObAddr& rescue_server); public: common::ObAddr server_; common::ObAddr rescue_server_; }; struct ObAdminRollingUpgradeArg { OB_UNIS_VERSION(1); public: ObAdminRollingUpgradeArg() : stage_(OB_UPGRADE_STAGE_MAX) {} ~ObAdminRollingUpgradeArg() {} bool is_valid() const; TO_STRING_KV(K_(stage)); ObUpgradeStage stage_; }; struct ObPreProcessServerReplyArg { OB_UNIS_VERSION(1); public: ObPreProcessServerReplyArg() : server_(), rescue_server_(), ret_code_(common::OB_SUCCESS) {} TO_STRING_KV(K_(server), K_(rescue_server), K_(ret_code)); bool is_valid() const { return server_.is_valid() && rescue_server_.is_valid(); } int init(const common::ObAddr& server, const common::ObAddr& rescue_server, const int ret_code); public: common::ObAddr server_; common::ObAddr rescue_server_; int ret_code_; }; struct ObRsListArg { OB_UNIS_VERSION(1); public: ObRsListArg() : rs_list_(), master_rs_() {} ~ObRsListArg() {} bool is_valid() const { return rs_list_.count() > 0 && master_rs_.is_valid(); } TO_STRING_KV(K_(rs_list), K_(master_rs)); ObServerList rs_list_; common::ObAddr master_rs_; }; struct ObLocationRpcRenewArg { OB_UNIS_VERSION(1); public: ObLocationRpcRenewArg() : keys_() {} ObLocationRpcRenewArg(common::ObIAllocator& allocator); ~ObLocationRpcRenewArg() {} bool is_valid() const { return keys_.count() > 0; } TO_STRING_KV(K_(keys)); common::ObSArray keys_; }; struct ObLocationRpcRenewResult { OB_UNIS_VERSION(1); public: ObLocationRpcRenewResult() : results_() {} ~ObLocationRpcRenewResult() {} bool is_valid() const { return results_.count() > 0; } TO_STRING_KV(K_(results)); common::ObSArray results_; }; struct ObGetMasterKeyResultArg { OB_UNIS_VERSION(1); public: ObGetMasterKeyResultArg() : str_(share::OB_CLOG_ENCRYPT_MASTER_KEY_LEN, 0, buf_) {} ~ObGetMasterKeyResultArg() {} bool is_valid() const { return true; } TO_STRING_KV(K_(str)); char buf_[share::OB_CLOG_ENCRYPT_MASTER_KEY_LEN]; common::ObString str_; }; struct ObKillPartTransCtxArg { OB_UNIS_VERSION(1); public: ObKillPartTransCtxArg() {} ~ObKillPartTransCtxArg() {} bool is_valid() const { return partition_key_.is_valid(); } TO_STRING_KV(K_(partition_key), K_(trans_id)); common::ObPartitionKey partition_key_; transaction::ObTransID trans_id_; }; struct ObPhysicalRestoreResult { OB_UNIS_VERSION(1); public: ObPhysicalRestoreResult(); virtual ~ObPhysicalRestoreResult() {} bool is_valid() const; int assign(const ObPhysicalRestoreResult& other); TO_STRING_KV(K_(job_id), K_(return_ret), K_(mod), K_(tenant_id), K_(trace_id), K_(addr)); int64_t job_id_; int32_t return_ret_; share::PhysicalRestoreMod mod_; uint64_t tenant_id_; common::ObCurTraceId::TraceId trace_id_; common::ObAddr addr_; }; struct ObExecuteRangePartSplitArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObExecuteRangePartSplitArg() : ObDDLArg(), partition_key_(), rowkey_() {} virtual ~ObExecuteRangePartSplitArg() {} bool is_valid() const; virtual bool is_allow_when_upgrade() const { return true; } virtual int assign(const ObExecuteRangePartSplitArg& other); common::ObPartitionKey partition_key_; common::ObRowkey rowkey_; TO_STRING_KV(K(partition_key_), K(rowkey_)); }; struct ObRefreshTimezoneArg { OB_UNIS_VERSION(1); public: ObRefreshTimezoneArg() : tenant_id_(common::OB_INVALID_TENANT_ID) {} ObRefreshTimezoneArg(uint64_t tenant_id) : tenant_id_(tenant_id) {} ~ObRefreshTimezoneArg() {} bool is_valid() const { return common::OB_INVALID_TENANT_ID != tenant_id_; } TO_STRING_KV(K_(tenant_id)); uint64_t tenant_id_; }; struct ObCreateRestorePointArg { OB_UNIS_VERSION(1); public: ObCreateRestorePointArg() : tenant_id_(0), name_() {} int assign(const ObCreateRestorePointArg& arg) { int ret = common::OB_SUCCESS; tenant_id_ = arg.tenant_id_; name_ = arg.name_; return ret; } bool is_valid() const { return tenant_id_ > 0 && !name_.empty(); } int64_t tenant_id_; common::ObString name_; TO_STRING_KV(K(tenant_id_), K(name_)); }; struct ObDropRestorePointArg { OB_UNIS_VERSION(1); public: ObDropRestorePointArg() : tenant_id_(0), name_() {} int assign(const ObDropRestorePointArg& arg) { int ret = common::OB_SUCCESS; tenant_id_ = arg.tenant_id_; name_ = arg.name_; return ret; } bool is_valid() const { return tenant_id_ > 0 && !name_.empty(); } int64_t tenant_id_; common::ObString name_; TO_STRING_KV(K(tenant_id_), K(name_)); }; struct ObCheckBuildIndexTaskExistArg { OB_UNIS_VERSION(1); public: ObCheckBuildIndexTaskExistArg() : tenant_id_(0), task_id_(), scheduler_id_(0) {} int assign(const ObCheckBuildIndexTaskExistArg& arg) { tenant_id_ = arg.tenant_id_; task_id_ = arg.task_id_; scheduler_id_ = arg.scheduler_id_; return common::OB_SUCCESS; } bool is_valid() const { return tenant_id_ > 0 && task_id_.is_valid(); } int64_t tenant_id_; sql::ObTaskID task_id_; uint64_t scheduler_id_; TO_STRING_KV(K_(tenant_id), K_(task_id), K_(scheduler_id)); }; struct ObPartitionBroadcastArg { OB_UNIS_VERSION(1); public: ObPartitionBroadcastArg() : keys_() {} ~ObPartitionBroadcastArg() {} bool is_valid() const; int assign(const ObPartitionBroadcastArg& other); TO_STRING_KV(K_(keys)); private: DISALLOW_COPY_AND_ASSIGN(ObPartitionBroadcastArg); public: common::ObSEArray keys_; }; struct ObPartitionBroadcastResult { OB_UNIS_VERSION(1); public: ObPartitionBroadcastResult() : ret_(common::OB_SUCCESS) {} ~ObPartitionBroadcastResult() {} bool is_valid() const; int assign(const ObPartitionBroadcastResult& other); TO_STRING_KV(K_(ret)); private: DISALLOW_COPY_AND_ASSIGN(ObPartitionBroadcastResult); public: int ret_; }; struct ObSubmitBuildIndexTaskArg : public ObDDLArg { OB_UNIS_VERSION(1); public: ObSubmitBuildIndexTaskArg() : ObDDLArg(), index_tid_(0) {} ~ObSubmitBuildIndexTaskArg() {} bool is_valid() const { return index_tid_ > 0; } virtual int assign(const ObSubmitBuildIndexTaskArg &other); TO_STRING_KV(K_(index_tid)); private: DISALLOW_COPY_AND_ASSIGN(ObSubmitBuildIndexTaskArg); public: uint64_t index_tid_; }; struct ObFetchSstableSizeArg final { OB_UNIS_VERSION(1); public: ObFetchSstableSizeArg() : pkey_(), index_id_(-1) {} ~ObFetchSstableSizeArg() {} bool is_valid() const { return pkey_.is_valid() && index_id_ > 0; } int assign(const ObFetchSstableSizeArg &other); TO_STRING_KV(K_(pkey), K_(index_id)); public: common::ObPartitionKey pkey_; int64_t index_id_; private: DISALLOW_COPY_AND_ASSIGN(ObFetchSstableSizeArg); }; struct ObFetchSstableSizeRes final { OB_UNIS_VERSION(1); public: ObFetchSstableSizeRes() : size_(0) {} ~ObFetchSstableSizeRes() {} int assign(const ObFetchSstableSizeRes &other); TO_STRING_KV(K_(size)); public: int64_t size_; private: DISALLOW_COPY_AND_ASSIGN(ObFetchSstableSizeRes); }; struct ObTTLRequestArg final { OB_UNIS_VERSION(1); public: enum TTLRequestType { TTL_TRIGGER_TYPE = 0, TTL_SUSPEND_TYPE = 1, TTL_RESUME_TYPE = 2, TTL_CANCEL_TYPE = 3, TTL_MOVE_TYPE = 4, TTL_INVALID_TYPE = 5 }; ObTTLRequestArg() : cmd_code_(-1), trigger_type_(-1), task_id_(OB_INVALID_ID), tenant_id_(OB_INVALID_ID) {} ~ObTTLRequestArg() = default; bool is_valid() const { return cmd_code_ != -1 && OB_INVALID_ID != task_id_ && trigger_type_ != -1 && tenant_id_ != OB_INVALID_ID; } int assign(const ObTTLRequestArg &other); TO_STRING_KV(K_(cmd_code), K_(trigger_type), K_(task_id), K_(tenant_id)); public: int32_t cmd_code_; // enum TTLCmdType int32_t trigger_type_; // system or user int64_t task_id_; // task id uint64_t tenant_id_; // tenand_id array }; struct ObTTLResult final { OB_UNIS_VERSION(1); public: ObTTLResult() : ret_code_(-1) {} ~ObTTLResult() = default; bool is_valid() const { return OB_INVALID_ID != ret_code_; } int assign(const ObTTLResult &other) { ret_code_ = other.ret_code_; return OB_SUCCESS; } TO_STRING_KV(K_(ret_code)); public: int32_t ret_code_; // SUCCESS or error code }; struct ObTTLResponseArg { OB_UNIS_VERSION(1); public: ObTTLResponseArg(); TO_STRING_KV(K_(tenant_id), K_(task_id), K_(server_addr), K_(task_status)); public: uint64_t tenant_id_; int64_t task_id_; ObAddr server_addr_; uint8_t task_status_; }; } // end namespace obrpc } // end namespace oceanbase #endif