mock_ob_partition.h

/**
 * 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.
 */

#include "storage/ob_i_partition_group.h"
#include "storage/ob_replay_status.h"
#include "storage/ob_saved_storage_info.h"
#include "storage/ob_pg_all_meta_checkpoint_writer.h"
#include "storage/ob_i_partition_report.h"
#include "gmock/gmock.h"
#include "common/ob_range.h"
#include "share/ob_partition_modify.h"
#include "share/stat/ob_table_stat.h"
#include "clog/ob_log_define.h"

#ifndef OCEANBASE_STORAGE_MOCK_OB_PARTITION_H_
#define OCEANBASE_STORAGE_MOCK_OB_PARTITION_H_

namespace oceanbase {
namespace storage {
class MockObIPartitionGroup : public ObIPartitionGroup {
public:
  MOCK_METHOD8(init, int(const common::ObPartitionKey& key, ObIPartitionComponentFactory* cp_fty,
                         share::schema::ObMultiVersionSchemaService* schema_service, transaction::ObTransService* txs,
                         replayengine::ObILogReplayEngine* rp_eg, ObPartitionService* ps,
                         ObPartitionGroupIndex* pg_index, ObPGPartitionMap* pg_partition_map));
  MOCK_METHOD0(destroy, void());
  // get partition log service
  MOCK_CONST_METHOD0(get_log_service, const clog::ObIPartitionLogService*());
  MOCK_METHOD0(get_log_service, clog::ObIPartitionLogService*());
  MOCK_METHOD1(is_replica_need_gc, int(bool& is_offline));

  MOCK_METHOD0(get_partition_service, ObPartitionService*());
  MOCK_METHOD0(get_pg_index, ObPartitionGroupIndex*());
  MOCK_METHOD0(get_pg_partition_map, ObPGPartitionMap*());
  MOCK_METHOD0(get_trans_service, transaction::ObTransService*());
  // get partition storage
  MOCK_CONST_METHOD0(get_partition_key, const common::ObPartitionKey&());

  MOCK_METHOD2(table_scan, int(ObTableScanParam& param, common::ObNewRowIterator*& result));
  MOCK_METHOD2(table_scan, int(ObTableScanParam& param, common::ObNewIterIterator*& result));
  MOCK_METHOD4(join_mv_scan, int(ObTableScanParam& left_param, ObTableScanParam& right_param,
                                 ObIPartitionGroup& right_partition, common::ObNewRowIterator*& result));
  MOCK_METHOD1(revert_scan_iter, int(common::ObNewRowIterator* iter));
  MOCK_METHOD1(revert_scan_iter, int(common::ObNewIterIterator* iter));
  MOCK_METHOD5(delete_rows,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& column_ids,
          common::ObNewRowIterator* row_iter, int64_t& affected_rows));
  MOCK_METHOD4(delete_row, int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
                               const common::ObIArray<uint64_t>& column_ids, const common::ObNewRow& row));
  MOCK_METHOD5(put_rows,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& column_ids,
          common::ObNewRowIterator* row_iter, int64_t& affected_rows));
  MOCK_METHOD5(insert_rows,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& column_ids,
          common::ObNewRowIterator* row_iter, int64_t& affected_rows));
  MOCK_METHOD8(insert_row,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& column_ids,
          const common::ObIArray<uint64_t>& duplicated_column_ids, const common::ObNewRow& row, const ObInsertFlag flag,
          int64_t& affected_rows, common::ObNewRowIterator*& duplicated_rows));
  MOCK_METHOD4(insert_row, int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param,
                               const common::ObIArray<uint64_t>& column_ids, const common::ObNewRow& row));
  MOCK_METHOD6(fetch_conflict_rows,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& in_column_ids,
          const common::ObIArray<uint64_t>& out_column_ids, common::ObNewRowIterator& check_row_iter,
          common::ObIArray<common::ObNewRowIterator*>& dup_row_iters));
  MOCK_METHOD2(revert_insert_iter, int(const common::ObPartitionKey& pkey, common::ObNewRowIterator* iter));
  MOCK_METHOD6(update_rows,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const common::ObIArray<uint64_t>& column_ids,
          const common::ObIArray<uint64_t>& updated_column_ids, common::ObNewRowIterator* row_iter,
          int64_t& affected_rows));
  MOCK_METHOD6(update_row,
      int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, 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_METHOD6(lock_rows, int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const int64_t abs_lock_timeout,
                              common::ObNewRowIterator* row_iter, const ObLockFlag lock_flag, int64_t& affected_rows));
  MOCK_METHOD5(lock_rows, int(const ObStoreCtx& ctx, const ObDMLBaseParam& dml_param, const int64_t abs_lock_timeout,
                              const common::ObNewRow& row, ObLockFlag lock_flag));

  MOCK_METHOD0(set_valid, int());
  MOCK_CONST_METHOD0(is_valid, bool());
  MOCK_METHOD2(get_migrating_store, int(const common::ObVersion& migrate_version, ObTablesHandle& handle));

  // leader or follower
  MOCK_CONST_METHOD1(get_role, int(common::ObRole& role));
  MOCK_CONST_METHOD1(get_role_unsafe, int(common::ObRole& role));
  MOCK_CONST_METHOD1(get_leader_curr_member_list, int(common::ObMemberList& member_list));
  MOCK_CONST_METHOD1(get_leader, int(common::ObAddr& addr));
  MOCK_CONST_METHOD1(get_curr_member_list, int(common::ObMemberList& member_list));
  MOCK_CONST_METHOD1(get_curr_member_list_for_report, int(common::ObMemberList& member_list));
  MOCK_CONST_METHOD2(get_curr_member_list, int(const common::ObPartitionKey& pkey, common::ObMemberList& member_list));
  MOCK_CONST_METHOD4(get_curr_leader_and_memberlist,
      int(common::ObAddr& leader, common::ObRole& role, common::ObMemberList& curr_member_list,
          common::ObChildReplicaList& children_list));
  MOCK_CONST_METHOD1(get_dst_leader_candidate, int(common::ObMemberList& member_list));
  MOCK_CONST_METHOD1(get_log_archive_status, int(clog::ObPGLogArchiveStatus& status));
  MOCK_METHOD1(change_leader, int(const common::ObAddr& leader));
  MOCK_METHOD0(leader_takeover, int());
  MOCK_METHOD0(leader_revoke, int());
  MOCK_METHOD0(leader_active, int());
  MOCK_METHOD0(get_replay_status, ObReplayStatus*());
  MOCK_METHOD0(adjust_freeze_status, int());
  MOCK_METHOD1(retire_warmup_store, int(const bool is_disk_full));
  MOCK_METHOD1(enable_write_log, int(const bool replay_old));
  MOCK_METHOD2(get_pg_partition, int(const common::ObPartitionKey& pkey, ObPGPartitionGuard& guard));

  // write ssstore objects @version tree to data file , used by write_check_point
  MOCK_CONST_METHOD3(serialize, int(char* buf, const int64_t buf_len, int64_t& pos));
  MOCK_METHOD3(serialize, int(ObArenaAllocator& allocator, char*& new_buf, int64_t& serialize_len));
  // read ssstore objects from data file to construct partition storage's version tree.
  MOCK_METHOD3(deserialize, int(const char* buf, const int64_t buf_len, int64_t& pos));
  MOCK_METHOD3(deserialize_v1, int(const char* buf, const int64_t buf_len, int64_t& pos));

  MOCK_CONST_METHOD0(get_serialize_size, int64_t());

  MOCK_METHOD1(get_create_ts, int(int64_t& create_ts));
  MOCK_CONST_METHOD0(get_cur_min_log_service_ts, int64_t());
  MOCK_CONST_METHOD0(get_cur_min_trans_service_ts, int64_t());
  MOCK_CONST_METHOD0(get_cur_min_replay_engine_ts, int64_t());
  MOCK_METHOD1(set_migrating_flag, void(const bool flag));
  MOCK_CONST_METHOD0(get_migrating_flag, bool());
  MOCK_METHOD0(replay_status_revoke, void());
  MOCK_METHOD0(report_clog_history_online, int());
  MOCK_METHOD0(report_clog_history_offline, int());

  MOCK_METHOD1(offline_itself, int(const bool));
  MOCK_CONST_METHOD0(is_removed, bool());
  MOCK_CONST_METHOD1(check_is_in_member_list, int(bool& is_in_member_list));
  MOCK_METHOD4(add_partition_to_pg, int(const int64_t log_type, const obrpc::ObCreatePartitionArg& arg,
                                        ObPartitionService* ps, ObAddPartitionToPGLogCb*& out_cb));

  MOCK_METHOD6(retry_raise_memstore_until_timeout,
      int(const ObFrozenStatus& frozen_status, const bool switch_state, const int64_t wait_freeze_interval,
          const int64_t expired_time, transaction::ObTransService* txs, ObFreezeLogCb* freeze_log_cb));
  MOCK_METHOD5(
      raise_memstore, int(const ObFrozenStatus& frozen_status, const bool switch_state, const int64_t expired_time,
                          transaction::ObTransService* txs, ObFreezeLogCb* freeze_log_cb));
  MOCK_METHOD3(raise_memstore,
      int(const ObFrozenStatus& frozen_status, const ObSavedStorageInfo& info, transaction::ObTransService* txs));
  MOCK_METHOD3(submit_freeze_log,
      int(const ObStorageLogType log_type, const ObSavedStorageInfo& info, ObFreezeLogCb* freeze_log_cb));
  MOCK_METHOD4(decode_freeze_log, int(const char* log, const int64_t size, int64_t& pos, ObSavedStorageInfo& info));
  MOCK_METHOD4(replay_partition_meta_log,
      int(const ObStorageLogType log_type, const int64_t log_id, const char* buf, const int64_t size));
  MOCK_METHOD0(set_wait_split, int());
  MOCK_METHOD1(save_split_state, int(const bool write_slog));
  MOCK_METHOD1(restore_split_state, int(const int state));
  MOCK_METHOD1(restore_split_info, int(const ObPartitionSplitInfo& split_info));
  MOCK_METHOD3(
      replay_split_source_log, int(const ObPartitionSplitSourceLog& log, const uint64_t log_id, const int64_t log_ts));
  MOCK_METHOD1(replay_split_dest_log, int(const ObPartitionSplitDestLog& log));
  MOCK_METHOD2(sync_split_source_log_success, int(const int64_t log_id, const int64_t log_ts));
  MOCK_METHOD0(sync_split_dest_log_success, int());
  MOCK_METHOD3(prepare_splitting,
      int(const ObPartitionSplitInfo& split_info, const common::ObMemberList& mlist, const common::ObAddr& leader));
  MOCK_METHOD3(split_source_partition, int(const int64_t schema_version, const share::ObSplitPartitionPair& info,
                                           enum share::ObSplitProgress& partition_progress));
  MOCK_METHOD2(
      split_dest_partition, int(const ObPartitionSplitInfo& split_info, enum share::ObSplitProgress& progress));
  MOCK_METHOD1(replay_split_state_slog, int(const ObSplitPartitionStateLogEntry& log_entry));
  MOCK_METHOD1(replay_split_info_slog, int(const ObSplitPartitionInfoLogEntry& log_entry));
  MOCK_METHOD3(set_dest_partition_split_progress,
      int(const int64_t schema_version, const common::ObPartitionKey& pkey, const int progress));
  MOCK_METHOD2(get_all_table_ids, int(const ObPartitionKey& pkey, common::ObIArray<uint64_t>& index_tables));
  MOCK_METHOD3(get_reference_tables, int(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle));
  MOCK_METHOD1(get_reference_memtables, int(ObTablesHandle& handle));
  MOCK_METHOD3(set_reference_tables, int(const ObPartitionKey& pkey, const int64_t index_id, ObTablesHandle& handle));
  MOCK_METHOD1(set_split_version, int(const int64_t split_version));
  MOCK_METHOD0(set_source_tables_refered, int());
  MOCK_METHOD5(get_split_table_ids, int(const common::ObVersion& merge_version, bool is_minor_split, bool& need_split,
                                        bool& need_minor_split, common::ObIArray<uint64_t>& index_tables));
  MOCK_METHOD1(check_can_migrate, int(bool& can_migrate));
  MOCK_CONST_METHOD0(is_splitting, bool());
  MOCK_CONST_METHOD0(is_split_source_partition, bool());
  MOCK_CONST_METHOD0(is_in_dest_split, bool());
  MOCK_CONST_METHOD0(is_dest_logical_split_finish, bool());
  MOCK_CONST_METHOD0(check_split_state, int());
  MOCK_METHOD2(get_split_progress, int(const int64_t schema_version, int& progress));
  MOCK_METHOD2(set_split_progress, int(const common::ObAddr& replica, const int progress));
  MOCK_METHOD1(check_physical_split, int(bool& finished));
  MOCK_METHOD0(block_partition_split_by_mc, int());
  MOCK_METHOD0(unblock_partition_split_by_mc, int());
  MOCK_METHOD1(need_replay_redo, bool(const int64_t log_id));
  MOCK_CONST_METHOD0(get_freeze_snapshot_ts, int64_t());

  MOCK_METHOD1(get_frozen_version, int(common::ObVersion& frozen_version));
  MOCK_CONST_METHOD1(get_merged_version, int(common::ObVersion& merged_version));
  MOCK_CONST_METHOD1(get_active_version, int(common::ObVersion& active_version));
  MOCK_METHOD1(set_frozen_version, int(const common::ObVersion& frozen_version));
  MOCK_METHOD1(effect_new_active_memstore, int(common::ObVersion& version));
  MOCK_METHOD0(revert_new_active_memstore, int());
  MOCK_CONST_METHOD0(get_partition_state, ObPartitionState());
  MOCK_METHOD1(switch_partition_state, int(const ObPartitionState state));
  MOCK_METHOD1(try_switch_partition_state, int(const ObPartitionState state));
  MOCK_METHOD1(get_safe_publish_version, int(int64_t& publish_version));
  MOCK_METHOD1(get_ssstore_max_version, int(oceanbase::common::ObVersion&));
  MOCK_METHOD1(get_base_ssstore_max_version, int(oceanbase::common::ObVersion&));
  MOCK_METHOD1(do_warm_up_request, int(const oceanbase::storage::ObIWarmUpRequest*));
  MOCK_METHOD2(check_can_do_merge, int(bool& can_merge, bool& need_merge));
  MOCK_METHOD0(get_cur_min_log_service_ts, int64_t());
  MOCK_METHOD0(get_cur_min_trans_service_ts, int64_t());
  MOCK_METHOD0(get_cur_min_replay_engine_ts, int64_t());
  MOCK_METHOD3(
      check_can_do_minor_merge, int(ObIPartitionStorage* storage, const int64_t frozen_version, bool& can_merge));
  MOCK_METHOD1(raise_minor_memstore, int(const ObFrozenStatus& frozen_status));
  MOCK_METHOD2(set_replica_type, int(const common::ObReplicaType& replica_type, const bool write_redo_log));
  MOCK_CONST_METHOD0(get_replica_type, common::ObReplicaType());
  MOCK_CONST_METHOD0(get_replica_property, common::ObReplicaProperty());
  MOCK_CONST_METHOD0(is_replica_using_remote_memstore, bool());
  MOCK_CONST_METHOD0(is_share_major_in_zone, bool());
  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(get_latest_schema_version, int(share::schema::ObMultiVersionSchemaService* schema_service,
                                              const common::ObPartitionKey& pkey, int64_t& latest_schema_version));
  MOCK_METHOD3(freeze, int(const bool emergency, const bool force, int64_t& freeze_snapshot));
  MOCK_METHOD1(mark_dirty_trans, int(bool& cleared));
  MOCK_METHOD4(get_curr_storage_info_for_migrate,
      int(const bool use_slave_safe_read_ts, const common::ObReplicaType replica_type, const int64_t src_cluster_id,
          ObSavedStorageInfoV2& info));

  MOCK_CONST_METHOD1(check_is_from_restore, int(bool& is_from_restore));
  MOCK_CONST_METHOD1(get_all_saved_info, int(ObSavedStorageInfoV2& info));
  MOCK_CONST_METHOD1(get_saved_clog_info, int(common::ObBaseStorageInfo& clog_info));
  MOCK_CONST_METHOD1(get_saved_data_info, int(ObDataStorageInfo& data_info));
  MOCK_CONST_METHOD2(get_saved_last_log_info, int(uint64_t& log_id, int64_t& submit_timestamp));

  MOCK_METHOD0(get_split_info, ObPartitionSplitInfo&());
  MOCK_METHOD1(check_cur_partition_split, int(bool& is_split_partition));
  MOCK_METHOD1(get_trans_split_info, int(transaction::ObTransSplitInfo& split_info));
  MOCK_METHOD2(
      check_single_replica_major_sstable_exist, int(const common::ObPartitionKey& pkey, const uint64_t index_table_id));
  MOCK_CONST_METHOD1(get_max_decided_trans_version, int(int64_t& max_decided_trans_version));

  MOCK_METHOD3(
      create_memtable, int(const bool in_slog_trans, const bool is_replay, const bool ignore_memstore_percent));
  MOCK_METHOD2(get_table_stat, int(const common::ObPartitionKey& pkey, common::ObTableStat& stat));
  MOCK_METHOD1(get_checkpoint, int(int64_t& checkpoint));
  MOCK_METHOD1(update_last_checkpoint, int(const int64_t checkpoint));
  MOCK_METHOD1(set_replay_checkpoint, int(const int64_t checkpoint));
  MOCK_METHOD2(update_max_majority_log, int(const uint64_t log_id, const int64_t log_ts));
  //  MOCK_METHOD1(get_replay_checkpoint, int(int64_t &checkpoint));
  int get_replay_checkpoint(int64_t& checkpoint)
  {
    checkpoint = 100;
    return common::OB_SUCCESS;
  }
  MOCK_METHOD1(allow_gc, int(bool& allow_gc));
  MOCK_METHOD3(gc_check_valid_member, int(const bool is_valid, const int64_t gc_seq, bool& need_gc));
  MOCK_METHOD1(check_pg_partition_offline, bool(const ObPartitionKey& pkey));
  MOCK_CONST_METHOD4(check_offline_log_archived,
      int(const ObPartitionKey& pkey, const int64_t incarnation, const int64_t archive_round, bool& has_archived));
  MOCK_CONST_METHOD1(get_leader_epoch, int(int64_t& leader_epoch));
  MOCK_METHOD0(clear_pg_non_reused_stores, int());
  MOCK_METHOD0(clear_sstables_after_relay_point, int());
  MOCK_METHOD1(get_replica_status, int(share::ObReplicaStatus& status));
  MOCK_METHOD1(set_storage_info, int(const ObSavedStorageInfoV2& info));
  MOCK_METHOD1(fill_replica, int(share::ObPartitionReplica& replica));
  MOCK_METHOD3(fill_pg_partition_replica,
      int(const ObPartitionKey& pkey, share::ObReplicaStatus& replica_status, ObReportStatus& report_status));
  MOCK_METHOD0(get_gc_schema_drop_ts, int64_t());
  MOCK_CONST_METHOD1(get_merge_priority_info, int(memtable::ObMergePriorityInfo& info));
  MOCK_METHOD0(set_need_rebuild, void());
  MOCK_CONST_METHOD0(is_need_rebuild, bool());
  void set_need_standby_restore()
  {
    return;
  }
  bool is_need_standby_restore() const
  {
    return false;
  }
  void reset_migrate_retry_flag()
  {
    return;
  }
  void set_need_gc()
  {
    return;
  }
  bool is_need_gc() const
  {
    return false;
  }
  uint64_t get_offline_log_id() const
  {
    return 0;
  }
  int set_offline_log_id(const uint64_t log_id)
  {
    UNUSED(log_id);
    return common::OB_SUCCESS;
  }
  MOCK_METHOD0(get_min_replayed_log_id, uint64_t());
  MOCK_METHOD2(get_min_replayed_log_with_keepalive, int(uint64_t& min_replay_log_id, int64_t& min_replay_log_ts));
  MOCK_CONST_METHOD1(get_table_store_cnt, int(int64_t& table_cnt));
  MOCK_METHOD4(
      check_dirty_txn, int(const int64_t min_log_ts, const int64_t max_log_ts, int64_t& freeze_ts, bool& is_dirty));
  MOCK_METHOD1(create_partition_group, int(const ObCreatePGParam& param));
  MOCK_METHOD8(create_pg_partition,
      int(const common::ObPartitionKey& pkey, const int64_t multi_version_start, const uint64_t data_table_id,
          const obrpc::ObCreatePartitionArg& arg, const bool in_slog_trans, const bool is_replay, const uint64_t log_id,
          ObTablesHandle& sstables_handle));
  MOCK_METHOD8(create_pg_partition,
      int(const common::ObPartitionKey& pkey, const int64_t multi_version_start, const uint64_t data_table_id,
          const ObCreatePartitionParam& arg, const bool in_slog_trans, const bool is_replay, const uint64_t log_id,
          ObTablesHandle& sstables_handle));
  MOCK_METHOD2(replay_pg_partition, int(const common::ObPartitionKey& pkey, const uint64_t log_id));
  MOCK_METHOD0(get_pg_storage, ObPGStorage&());
  bool is_pg() const
  {
    return false;
  }
  MOCK_METHOD2(get_all_pg_partition_keys, int(ObPartitionArray& pkeys, const bool include_trans_table));
  MOCK_METHOD5(
      submit_add_partition_to_pg_log, int(const obrpc::ObCreatePartitionArg& arg, ObPartitionService* ps,
                                          uint64_t& log_id, int64_t& log_ts, ObAddPartitionToPGLogCb*& out_cb));
  MOCK_METHOD1(submit_remove_partition_from_pg_log, int(const ObPartitionKey& pkey));
  MOCK_METHOD4(remove_partition_from_pg,
      int(const bool for_replay, const ObPartitionKey& pkey, const bool write_slog_trans, const uint64_t log_id));
  MOCK_METHOD7(submit_partition_schema_change_log,
      int(const common::ObPartitionKey& pkey, const int64_t schema_version, const uint64_t index_id,
          ObPartitionService* ps, uint64_t& log_id, int64_t& log_ts, ObSchemaChangeClogCb*& out_cb));
  MOCK_METHOD5(add_sstable_for_merge,
      int(const ObPartitionKey& pkey, storage::ObSSTable* sstable, const int64_t max_kept_major_version_number,
          ObIPartitionReport& report, ObSSTable* complement_minor_sstable));
  MOCK_METHOD1(check_replica_ready_for_bounded_staleness_read, int(const int64_t snapshot_version));
  MOCK_METHOD1(feedback_scan_access_stat, int(const ObTableScanParam& param));

  MOCK_METHOD0(pause, int());
  MOCK_METHOD0(stop, int());
  MOCK_METHOD0(offline, int());
  MOCK_METHOD3(create_sstables, int(const common::ObIArray<storage::ObPGCreateSSTableParam>& create_sstable_params,
                                    ObTablesHandle& tables_handle, const bool in_slog_trans));
  MOCK_METHOD3(create_sstable,
      int(const storage::ObPGCreateSSTableParam& param, ObTableHandle& table_handle, const bool in_slog_trans));
  MOCK_METHOD2(get_checkpoint_info, int(common::ObArenaAllocator& allocator, ObPGCheckpointInfo& pg_checkpoint_info));
  MOCK_METHOD2(acquire_sstable, int(const ObITable::TableKey& table_key, ObTableHandle& table_handle));
  MOCK_METHOD1(set_storage_file, int(ObStorageFileHandle& file));
  MOCK_METHOD1(set_meta_block_list, int(const common::ObIArray<blocksstable::MacroBlockId>& meta_block_list));
  MOCK_METHOD3(schema_drop, int(const bool, const uint64_t, const bool));
  MOCK_METHOD1(check_source_partition_status, int(bool& can_offline));
  MOCK_CONST_METHOD0(need_replay_redo, bool());
  MOCK_METHOD0(try_clear_split_info, int());
  MOCK_METHOD1(check_complete, int(bool& is_complete));
  MOCK_METHOD5(
      try_update_clog_member_list, int(const uint64_t ms_log_id, const int64_t mc_timestamp, const int64_t replica_num,
                                       const ObMemberList& mlist, const common::ObProposalID& ms_proposal_id));
  MOCK_METHOD1(physical_flashback, int(const int64_t flashback_scn));
  MOCK_METHOD1(check_can_physical_flashback, int(const int64_t flashback_scn));
  MOCK_METHOD2(register_txs_change_leader, int(const common::ObAddr& server, ObTsWindows& changing_leader_windows));
  MOCK_METHOD4(try_update_clog_member_list,
      int(const uint64_t ms_log_id, const int64_t mc_timestamp, const int64_t replica_num, const ObMemberList& mlist));
  MOCK_METHOD3(
      check_physical_flashback_succ, int(const obrpc::ObCheckPhysicalFlashbackArg& arg, const int64_t max_version,
                                         obrpc::ObPhysicalFlashbackResultArg& result));
  MOCK_METHOD1(save_split_info, int(const ObPartitionSplitInfo& split_info));
  MOCK_METHOD1(save_split_state, int(const int64_t split_state));
  MOCK_METHOD3(
      shutdown, int(const int64_t snapshot_version, const uint64_t replay_log_id, const int64_t schema_version));
  MOCK_METHOD0(get_partition_loop_worker, ObPartitionLoopWorker*());
  MOCK_METHOD2(push_reference_tables,
      int(const common::ObIArray<common::ObPartitionKey>& dest_array, const int64_t split_version));
  MOCK_CONST_METHOD1(get_meta_block_list, int(common::ObIArray<blocksstable::MacroBlockId>& meta_block_list));
  MOCK_METHOD1(get_all_tables, int(ObTablesHandle& tables_handle));
  MOCK_METHOD2(recycle_unused_sstables, int(const int64_t max_recycle_cnt, int64_t& recycled_cnt));
  MOCK_METHOD1(recycle_sstable, int(const ObITable::TableKey &table_key));
  MOCK_METHOD1(check_can_free, int(bool& can_free));
  MOCK_METHOD0(clear, void());
  MOCK_METHOD1(get_merge_log_ts, int(int64_t& merge_log_ts));
  MOCK_METHOD2(check_ready_for_split, int(const ObPartitionArray& src_pkeys, bool& is_ready));
  MOCK_METHOD2(clear_trans_after_restore_log, int(const uint64_t last_restore_log_id, const int64_t last_restore_log_ts));
  MOCK_METHOD0(reset_for_replay, int());
  MOCK_METHOD2(inc_pending_batch_commit_count, int(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts));
  MOCK_METHOD2(inc_pending_elr_count, int(memtable::ObMemtableCtx& mt_ctx, const int64_t log_ts));
};

}  // namespace storage
}  // namespace oceanbase
#endif  // OCEANBASE_STORAGE_MOCK_OB_PARTITION_H_