329 lines
21 KiB
C++
329 lines
21 KiB
C++
/**
|
|
* 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 MOCK_OB_PARTITION_SERVICE_H_
|
|
#define MOCK_OB_PARTITION_SERVICE_H_
|
|
#define private public
|
|
|
|
#undef private
|
|
#undef protected
|
|
#include <gmock/gmock.h>
|
|
#define private public
|
|
#define protected public
|
|
#include "common/ob_i_rs_cb.h"
|
|
#include "share/ob_rpc_struct.h"
|
|
#include "share/ob_server_locality_cache.h"
|
|
#include "common/storage/ob_freeze_define.h"
|
|
#include "clog/ob_clog_mgr.h"
|
|
#include "clog/ob_log_rpc_proxy.h"
|
|
#include "storage/transaction/ob_trans_define.h"
|
|
#include "storage/transaction/ob_trans_service.h"
|
|
#include "storage/ob_partition_group.h"
|
|
#include "storage/ob_partition_service_rpc.h"
|
|
#include "storage/blocksstable/ob_local_file_system.h"
|
|
#include "storage/ob_partition_service.h"
|
|
#include "storage/ob_pg_storage.h"
|
|
#include "sql/ob_end_trans_callback.h"
|
|
|
|
namespace oceanbase {
|
|
using namespace blocksstable;
|
|
namespace storage {
|
|
|
|
class MockObIPartitionService : public ObPartitionService {
|
|
public:
|
|
MOCK_METHOD0(reload_config, int());
|
|
MOCK_METHOD1(on_leader_revoke, int(const common::ObPartitionKey& partition_key));
|
|
MOCK_METHOD1(on_leader_takeover, int(const common::ObPartitionKey& partition_key));
|
|
MOCK_METHOD1(on_leader_active, int(const common::ObPartitionKey& partition_key));
|
|
MOCK_METHOD1(internal_leader_revoke, int(const ObCbTask& revoke_task));
|
|
MOCK_METHOD1(internal_leader_takeover, int(const ObCbTask& takeover_task));
|
|
MOCK_METHOD1(internal_leader_active, int(const ObCbTask& active_task));
|
|
MOCK_METHOD2(async_leader_revoke, int(const common::ObPartitionKey& pkey, const uint32_t revoke_type));
|
|
MOCK_METHOD7(on_member_change_success,
|
|
int(const common::ObPartitionKey& partition_key, const uint64_t ms_log_id, const int64_t mc_timestamp,
|
|
const int64_t replica_num, const common::ObMemberList& prev_member_list,
|
|
const common::ObMemberList& curr_member_list, const common::ObProposalID& ms_proposal_id));
|
|
MOCK_CONST_METHOD1(is_take_over_done, bool(const common::ObPartitionKey& partition_key));
|
|
MOCK_CONST_METHOD1(is_revoke_done, bool(const common::ObPartitionKey& partition_key));
|
|
MOCK_METHOD1(is_tenant_active, bool(const common::ObPartitionKey& partition_key));
|
|
MOCK_METHOD3(
|
|
get_leader_from_loc_cache, int(const common::ObPartitionKey& pkey, ObAddr& leader, const bool is_need_renew));
|
|
MOCK_METHOD2(handle_log_missing, int(const common::ObPartitionKey& pkey, const common::ObAddr& server));
|
|
MOCK_METHOD2(get_last_ssstore_version, int(const common::ObPartitionKey& pkey, common::ObVersion& version));
|
|
MOCK_METHOD2(check_partition_index_available, int(const common::ObPartitionKey& pkey, bool& available));
|
|
MOCK_METHOD1(push_callback_task, int(const ObCbTask& task));
|
|
MOCK_METHOD1(activate_tenant, int(const uint64_t tenant_id));
|
|
MOCK_METHOD1(inactivate_tenant, int(const uint64_t tenant_id));
|
|
|
|
MOCK_CONST_METHOD2(get_server_locality_array,
|
|
int(common::ObIArray<share::ObServerLocality>& server_locality_array, bool& has_readonly_zone));
|
|
MOCK_METHOD0(force_refresh_locality_info, int());
|
|
|
|
MOCK_METHOD8(init,
|
|
int(const blocksstable::ObStorageEnv& env, const common::ObAddr& self_addr, ObIPartitionComponentFactory* cp_fty,
|
|
share::schema::ObMultiVersionSchemaService* schema_service, share::ObIPartitionLocationCache* location_cache,
|
|
share::ObRsMgr* rs_mgr, ObIPartitionReport* rs_cb, rpc::frame::ObReqTransport* req_transport));
|
|
|
|
MOCK_METHOD2(create_batch_partition_groups,
|
|
int(const common::ObIArray<obrpc::ObCreatePartitionArg>& batch_arg, common::ObIArray<int>& batch_res));
|
|
MOCK_METHOD2(create_batch_pg_partitions,
|
|
int(const common::ObIArray<obrpc::ObCreatePartitionArg>& batch_arg, common::ObIArray<int>& batch_res));
|
|
|
|
MOCK_METHOD0(start, int());
|
|
MOCK_METHOD0(stop, int());
|
|
MOCK_METHOD0(wait, int());
|
|
MOCK_METHOD0(destroy, int());
|
|
MOCK_METHOD3(load_partition, int(const char* buf, const int64_t buf_len, int64_t& pos));
|
|
MOCK_METHOD4(replay, int(const int64_t log_seq_num, const int64_t subcmd, const char* buf, const int64_t len));
|
|
MOCK_METHOD4(parse, int(const int64_t subcmd, const char* buf, const int64_t len, FILE* stream));
|
|
MOCK_METHOD4(create_partition, int(const common::ObPartitionKey& key, const common::ObVersion data_version,
|
|
const int64_t replica_num, const common::ObMemberList& mem_list));
|
|
MOCK_METHOD9(create_partition,
|
|
int(const common::ObPartitionKey& key, const int64_t schema_version, const common::ObVersion data_version,
|
|
const int64_t replica_num, const common::ObMemberList& mem_list, const common::ObAddr& leader,
|
|
const int64_t lease_start, const int64_t last_submit_timestamp,
|
|
const ObIArray<share::schema::ObTableSchema>& schemas));
|
|
MOCK_METHOD3(add_partition, int(const common::ObPartitionKey& key, const common::ObVersion data_version,
|
|
const common::ObBaseStorageInfo& info));
|
|
MOCK_METHOD5(
|
|
migrate_partition, int(const common::ObPartitionKey& key, const common::ObMember& src,
|
|
const common::ObMember& dst, const common::ObMember& replace, const bool keep_src));
|
|
MOCK_METHOD2(migrate_partition_callback, int(const obrpc::ObMigrateArg& arg, const int result));
|
|
MOCK_METHOD1(remove_partition, int(const common::ObPartitionKey& key));
|
|
MOCK_METHOD2(remove_partition_from_pg, int(const ObPartitionKey& pg_key, const ObPartitionKey& pkey));
|
|
MOCK_METHOD3(online_partition,
|
|
int(const common::ObPartitionKey& key, const common::ObVersion& mem_version, const int64_t publish_version));
|
|
MOCK_METHOD5(copy_local_index,
|
|
int(const common::ObPartitionKey& pkey, const uint64_t index_id, const common::ObReplicaMember& dst,
|
|
const common::ObReplicaMember& data_src, const share::ObTaskId& task_id));
|
|
MOCK_METHOD0(remove_orphans, int());
|
|
MOCK_METHOD0(freeze, int());
|
|
MOCK_CONST_METHOD0(get_min_using_file_id, int64_t());
|
|
MOCK_METHOD2(kill_query_session, int(const transaction::ObTransDesc& trans_desc, const int status));
|
|
MOCK_METHOD7(
|
|
start_trans, int(const uint64_t tenant_id, const uint64_t thread_id, const transaction::ObStartTransParam& req,
|
|
const int64_t expired_time, const uint32_t session_id, uint64_t proxy_session_id,
|
|
transaction::ObTransDesc& trans_desc));
|
|
MOCK_METHOD4(end_trans, int(bool is_rollback, transaction::ObTransDesc& trans_desc, sql::ObIEndTransCallback& cb,
|
|
const int64_t stmt_expired_time));
|
|
MOCK_CONST_METHOD2(get_curr_member_list, int(const common::ObPartitionKey& pkey, common::ObMemberList& member_list));
|
|
MOCK_METHOD5(start_stmt,
|
|
int(const uint64_t tenant_id, const transaction::ObStmtDesc& stmt_desc, transaction::ObTransDesc& trans_desc,
|
|
const int64_t expired_time, const common::ObPartitionArray& participants));
|
|
MOCK_METHOD5(start_stmt, int(const transaction::ObStmtParam& stmt_param, const transaction::ObStmtDesc& stmt_desc,
|
|
transaction::ObTransDesc& trans_desc, const common::ObPartitionLeaderArray& pla,
|
|
common::ObPartitionArray& participants));
|
|
MOCK_METHOD5(end_stmt, int(bool is_rollback, const ObPartitionArray& cur_stmt_all_participants,
|
|
const transaction::ObPartitionEpochArray& epoch_arr,
|
|
const ObPartitionArray& discard_participants, transaction::ObTransDesc& trans_desc));
|
|
MOCK_METHOD3(
|
|
start_participant, int(transaction::ObTransDesc& trans_desc, const common::ObPartitionArray& participants,
|
|
transaction::ObPartitionEpochArray& partition_epoch_arr));
|
|
MOCK_METHOD3(end_participant,
|
|
int(bool is_rollback, transaction::ObTransDesc& trans_desc, const common::ObPartitionArray& participants));
|
|
MOCK_METHOD2(do_warm_up_request, int(const oceanbase::obrpc::ObWarmUpRequestArg&, const int64_t));
|
|
MOCK_METHOD1(do_partition_loop_work, int(ObIPartitionGroup& partition));
|
|
MOCK_METHOD2(table_scan, int(ObVTableScanParam& param, common::ObNewRowIterator*& result));
|
|
MOCK_METHOD3(join_mv_scan, int(storage::ObTableScanParam& left_param, storage::ObTableScanParam& right_param,
|
|
common::ObNewRowIterator*& result));
|
|
MOCK_METHOD1(revert_scan_iter, int(common::ObNewRowIterator* iter));
|
|
MOCK_METHOD6(delete_rows, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
common::ObNewRowIterator* row_iter, int64_t& affected_rows));
|
|
MOCK_METHOD5(delete_row, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
const common::ObNewRow& row));
|
|
MOCK_METHOD6(put_rows, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
common::ObNewRowIterator* row_iter, int64_t& affected_rows));
|
|
MOCK_METHOD6(insert_rows, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
common::ObNewRowIterator* row_iter, int64_t& affected_rows));
|
|
MOCK_METHOD9(insert_row, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
const common::ObIArray<uint64_t>& duplicated_column_ids, const common::ObNewRow& row,
|
|
ObInsertFlag flag, int64_t& affected_rows, common::ObNewRowIterator*& duplicated_rows));
|
|
MOCK_METHOD5(insert_row, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
const common::ObNewRow& row));
|
|
MOCK_METHOD2(revert_insert_iter, int(const common::ObPartitionKey& pkey, common::ObNewRowIterator* iter));
|
|
MOCK_METHOD7(update_rows, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
const common::ObIArray<uint64_t>& updated_column_ids,
|
|
common::ObNewRowIterator* row_iter, int64_t& affected_rows));
|
|
MOCK_METHOD7(update_row, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const common::ObPartitionKey& pkey, const common::ObIArray<uint64_t>& column_ids,
|
|
const common::ObIArray<uint64_t>& updated_column_ids, const common::ObNewRow& old_row,
|
|
const common::ObNewRow& new_row));
|
|
|
|
MOCK_METHOD7(lock_rows, int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param,
|
|
const int64_t abs_lock_timeout, const common::ObPartitionKey& pkey,
|
|
common::ObNewRowIterator* row_iter, const ObLockFlag lock_flag, int64_t& affected_rows));
|
|
MOCK_METHOD6(lock_rows,
|
|
int(const transaction::ObTransDesc& trans_desc, const ObDMLBaseParam& dml_param, const int64_t abs_lock_timeout,
|
|
const common::ObPartitionKey& pkey, const common::ObNewRow& row, const ObLockFlag lock_flag));
|
|
MOCK_METHOD1(get_all_partitions, int(ObIPartitionArrayGuard& partitions));
|
|
MOCK_CONST_METHOD2(get_partition, int(const common::ObPartitionKey& pkey, ObIPartitionGroupGuard*& partition));
|
|
MOCK_METHOD2(get_partitions_by_file_key, int(const ObTenantFileKey& file_key, ObIPartitionArrayGuard& partitions));
|
|
MOCK_CONST_METHOD1(get_partition_count, int(int64_t& partition_count));
|
|
|
|
virtual int get_pg_key(const ObPartitionKey& pkey, ObPGKey& pg_key) const override
|
|
{
|
|
pg_key = pkey;
|
|
return common::OB_SUCCESS;
|
|
}
|
|
|
|
virtual int get_partition(const common::ObPartitionKey& pkey, ObIPartitionGroupGuard& guard) const
|
|
{
|
|
int ret = common::OB_SUCCESS;
|
|
ObStorageFileHandle file_handle;
|
|
ObPartitionGroup& pg = const_cast<ObPartitionGroup&>(mock_pg_);
|
|
guard.set_partition_group(this->get_pg_mgr(), pg);
|
|
ObStorageFile* tmp_file = guard.get_partition_group()->get_pg_storage().get_storage_file();
|
|
|
|
if (nullptr != tmp_file) {
|
|
// do nothing
|
|
_OB_LOG(INFO, "get partition exist tmp file=%p", tmp_file);
|
|
} else if (OB_FAIL(OB_SERVER_FILE_MGR.alloc_file(pkey.get_tenant_id(), false, file_handle))) {
|
|
_OB_LOG(WARN, "fail to alloc pg file");
|
|
} else if (OB_FAIL(guard.get_partition_group()->get_pg_storage().set_storage_file(file_handle))) {
|
|
_OB_LOG(WARN, "fail to set storage file");
|
|
} else {
|
|
_OB_LOG(INFO, "set storage file=%p", guard.get_partition_group()->get_pg_storage().get_storage_file());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
mock_pg_.get_pg_storage().destroy();
|
|
}
|
|
|
|
virtual int get_all_partition_status(int64_t& inactive_num, int64_t& total_num) const
|
|
{
|
|
inactive_num = 0;
|
|
total_num = 0;
|
|
return common::OB_SUCCESS;
|
|
}
|
|
virtual int get_replica_type(const common::ObPartitionKey& pkey, ObReplicaType& type) const
|
|
{
|
|
UNUSED(pkey);
|
|
type = REPLICA_TYPE_FULL;
|
|
return common::OB_SUCCESS;
|
|
}
|
|
MOCK_CONST_METHOD1(revert_replay_status, void(ObReplayStatus* replay_status));
|
|
// MOCK_METHOD0(alloc_partition_iter, ObIPartitionGroupIterator * ());
|
|
virtual ObIPartitionGroupIterator* alloc_pg_iter()
|
|
{
|
|
ObPartitionGroupIterator* part_iter = new ObPartitionGroupIterator();
|
|
part_iter->set_pg_mgr(const_cast<ObPGMgr&>(this->get_pg_mgr()));
|
|
return part_iter;
|
|
}
|
|
// MOCK_METHOD1(revert_partition_iter, void(ObIPartitionGroupIterator *iter));
|
|
virtual ObPGPartitionIterator* alloc_pg_partition_iter()
|
|
{
|
|
ObPGPartitionIterator* part_iter = new ObPGPartitionIterator();
|
|
part_iter->set_pg_mgr(const_cast<ObPGMgr&>(this->get_pg_mgr()));
|
|
return part_iter;
|
|
}
|
|
|
|
virtual void revert_pg_partition_iter(ObIPGPartitionIterator* iter)
|
|
{
|
|
delete iter;
|
|
}
|
|
MOCK_CONST_METHOD0(is_empty, bool());
|
|
MOCK_METHOD7(replay_redo_log, int(const common::ObPartitionKey& pkey, const ObStoreCtx& ctx, const int64_t ts,
|
|
const int64_t log_id, const char* buf, const int64_t size, bool& replayed));
|
|
MOCK_METHOD0(get_trans_service, transaction::ObTransService*());
|
|
MOCK_METHOD0(get_clog_mgr, clog::ObICLogMgr*());
|
|
MOCK_METHOD0(get_election_mgr, election::ObIElectionMgr*());
|
|
MOCK_METHOD2(sync_frozen_status, int(const ObFrozenStatus& frozen_status, const bool& force));
|
|
MOCK_METHOD3(replay, int(const ObPartitionKey& partition, const char* log, const int64_t size));
|
|
MOCK_METHOD1(minor_freeze, int(const uint64_t tenant_id));
|
|
MOCK_METHOD1(minor_freeze, int(const common::ObPartitionKey& pkey));
|
|
MOCK_METHOD3(minor_freeze,
|
|
int(const common::ObPartitionKey& pkey, const common::ObVersion& frozen_version, const int64_t frozen_timestamp));
|
|
MOCK_METHOD1(submit_freeze_log_success, int(const ObPartitionKey& pkey));
|
|
MOCK_METHOD1(submit_freeze_log_finished, int(const ObPartitionKey& pkey));
|
|
MOCK_METHOD1(is_freeze_replay_finished, bool(const ObPartitionKey& pkey));
|
|
MOCK_CONST_METHOD2(get_role, int(const common::ObPartitionKey& pkey, common::ObRole& role));
|
|
MOCK_CONST_METHOD2(
|
|
get_leader_curr_member_list, int(const common::ObPartitionKey& pkey, common::ObMemberList& member_list));
|
|
MOCK_CONST_METHOD7(get_curr_leader_and_memberlist,
|
|
int(const common::ObPartitionKey& pkey, oceanbase::common::ObAddr& leader, oceanbase::common::ObRole& role,
|
|
common::ObMemberList& member_list, common::ObChildReplicaList& children_list,
|
|
common::ObReplicaType& replica_type, common::ObReplicaProperty& property));
|
|
MOCK_CONST_METHOD2(
|
|
get_dst_leader_candidate, int(const common::ObPartitionKey& pkey, common::ObMemberList& member_list));
|
|
MOCK_CONST_METHOD2(get_leader, int(const common::ObPartitionKey& pkey, common::ObAddr& addr));
|
|
MOCK_METHOD2(change_leader, int(const common::ObPartitionKey& pkey, const common::ObAddr& leader));
|
|
MOCK_CONST_METHOD1(is_partition_exist, bool(const ObPartitionKey& pkey));
|
|
MOCK_METHOD0(is_scan_disk_finished, bool());
|
|
MOCK_METHOD0(is_inner_table_scan_finish, bool());
|
|
MOCK_METHOD2(add_temporary_replica, int(const common::ObPartitionKey& key, const common::ObMember& dst));
|
|
MOCK_METHOD3(is_member_change_done, int(const oceanbase::common::ObPartitionKey& key, uint64_t log_id, int64_t ts));
|
|
MOCK_METHOD2(remove_replica, int(const common::ObPartitionKey& key, const common::ObReplicaMember& dst));
|
|
MOCK_METHOD2(remove_replica_mc, int(const obrpc::ObMemberChangeArg& arg, obrpc::ObMCLogRpcInfo& info));
|
|
MOCK_METHOD2(
|
|
batch_remove_replica_mc, int(const obrpc::ObMemberChangeBatchArg& arg, obrpc::ObMemberChangeBatchResult& result));
|
|
MOCK_METHOD2(change_quorum_mc, int(const obrpc::ObModifyQuorumArg& arg, obrpc::ObMCLogRpcInfo& info));
|
|
MOCK_METHOD5(
|
|
add_replica, int(const common::ObPartitionKey& key, const common::ObReplicaMember& dst,
|
|
const common::ObReplicaMember& data_src, const int64_t quorum, const share::ObTaskId& task_id));
|
|
MOCK_METHOD6(migrate_replica,
|
|
int(const common::ObPartitionKey& key, const common::ObReplicaMember& src, const common::ObReplicaMember& dst,
|
|
const common::ObReplicaMember& data_src, const int64_t quorum, const share::ObTaskId& task_id));
|
|
MOCK_METHOD4(rebuild_replica, int(const common::ObPartitionKey& key, const common::ObReplicaMember& dst,
|
|
const common::ObReplicaMember& data_src, const share::ObTaskId& task_id));
|
|
MOCK_METHOD5(change_replica,
|
|
int(const common::ObPartitionKey& key, const common::ObReplicaMember& dst,
|
|
const common::ObReplicaMember& data_src, const int64_t quorum, const share::ObTaskId& task_id));
|
|
MOCK_METHOD2(add_replica_mc, int(const obrpc::ObMemberChangeArg& arg, obrpc::ObMCLogRpcInfo& info));
|
|
MOCK_METHOD2(get_scan_cost, int(const ObTableScanParam& param, ObPartitionEst& cost_estimate));
|
|
MOCK_METHOD2(get_status, int(const common::ObPartitionKey& pkey, int64_t& status));
|
|
MOCK_METHOD0(garbage_clean, void());
|
|
MOCK_METHOD0(get_rs_rpc_proxy, obrpc::ObCommonRpcProxy&());
|
|
MOCK_METHOD2(get_safe_publish_version, int(const common::ObPartitionKey& pkey, int64_t& publish_version));
|
|
MOCK_METHOD1(schema_drop_partition, int(const ObCLogCallbackAsyncTask& offline_task));
|
|
MOCK_METHOD1(migrate_replica_batch, int(const obrpc::ObMigrateReplicaBatchArg& arg));
|
|
MOCK_METHOD1(submit_offline_partition_task, int(const common::ObPartitionKey& pkey));
|
|
MOCK_METHOD2(get_frozen_status, int(const int64_t major_version, ObFrozenStatus& frozen_status));
|
|
MOCK_METHOD1(insert_frozen_status, int(const ObFrozenStatus& src));
|
|
MOCK_METHOD2(update_frozen_status, int(const ObFrozenStatus& src, const ObFrozenStatus& tgt));
|
|
MOCK_METHOD1(delete_frozen_status, int(const int64_t major_version));
|
|
MOCK_METHOD4(gene_all_partition_min_slave_read_ts,
|
|
int(int64_t& outer_safe_weak_read_timestamp, int64_t& inner_safe_weak_read_timestamp,
|
|
ObPartitionKey& outer_min_slave_read_ts_key, ObPartitionKey& inner_min_slave_read_ts_key));
|
|
MOCK_CONST_METHOD3(check_can_start_service,
|
|
int(bool& can_start_service, int64_t& safe_weak_read_snapshot, ObPartitionKey& min_slave_read_ts_key));
|
|
MOCK_METHOD2(generate_weak_read_timestamp, int(const common::ObPartitionKey& pkey, int64_t& timestamp));
|
|
MOCK_METHOD0(admin_wash_ilog_cache, int());
|
|
MOCK_METHOD1(admin_wash_ilog_cache, int(clog::file_id_t));
|
|
MOCK_METHOD1(set_zone_priority, void(const int64_t zone_priority));
|
|
MOCK_METHOD1(set_region, int(const common::ObRegion& region));
|
|
MOCK_METHOD3(append_local_sort_data,
|
|
int(const common::ObPartitionKey& pkey, const share::ObBuildIndexAppendLocalDataParam& param,
|
|
common::ObNewRowIterator& iter));
|
|
MOCK_METHOD3(append_sstable, int(const common::ObPartitionKey& pkey,
|
|
const share::ObBuildIndexAppendSSTableParam& param, common::ObNewRowIterator& iter));
|
|
MOCK_METHOD3(check_schema_version_elapsed,
|
|
int(const common::ObPartitionKey& pkey, const int64_t schema_version, int64_t& max_commit_version));
|
|
MOCK_METHOD2(check_ctx_create_timestamp_elapsed, int(const common::ObPartitionKey& pkey, const int64_t ts));
|
|
|
|
public:
|
|
ObPartitionGroup mock_pg_;
|
|
};
|
|
|
|
} // namespace storage
|
|
} // namespace oceanbase
|
|
#endif /* MOCK_OB_PARTITION_SERVICE_H_ */
|