master add transfer_dml_ctrl_42x serialized variables

2024-03-06 10:44:54 +00:00
parent 485f7cecfb
commit 200d4db9b8
7 changed files with 521 additions and 18 deletions
--- a/src/share/ob_cluster_version.h
+++ b/src/share/ob_cluster_version.h
@ -191,6 +191,7 @@ cal_version(const uint64_t major, const uint64_t minor, const uint64_t major_pat
 // 1. After 4.0, each cluster_version is corresponed to a data version.
 // 2. cluster_version and data_version is not compariable.
 // 3. TODO: If you update data_version below, please update DATA_CURRENT_VERSION & ObUpgradeChecker too.
+#define DEFAULT_MIN_DATA_VERSION (oceanbase::common::cal_version(0, 0, 0, 1))
 #define DATA_VERSION_4_0_0_0 (oceanbase::common::cal_version(4, 0, 0, 0))
 #define DATA_VERSION_4_1_0_0 (oceanbase::common::cal_version(4, 1, 0, 0))
 #define DATA_VERSION_4_1_0_1 (oceanbase::common::cal_version(4, 1, 0, 1))
--- a/src/storage/high_availability/ob_ls_transfer_info.cpp
+++ b/src/storage/high_availability/ob_ls_transfer_info.cpp
@ -31,7 +31,7 @@ int ObLSTransferInfo::init(
  int ret = OB_SUCCESS;
  if (!ls_id.is_valid() || !transfer_start_scn.is_valid_and_not_min()) {
    ret = OB_INVALID_ARGUMENT;
-    LOG_WARN("init transfer info get invalid agument", K(ret), K(ls_id), K(transfer_start_scn));
+    LOG_WARN("init transfer info get invalid argument", K(ret), K(ls_id), K(transfer_start_scn));
  } else {
    ls_id_ = ls_id;
    transfer_start_scn_ = transfer_start_scn;
@ -55,3 +55,371 @@ bool ObLSTransferInfo::already_enable_replay() const
 {
  return !is_valid();
 }
+
+bool ObTransferInTransStatus::is_valid(const ObTransferInTransStatus::STATUS &status)
+{
+  return status >= NONE && status < MAX;
+}
+
+bool ObTransferInTransStatus::can_skip_barrier(const ObTransferInTransStatus::STATUS &status)
+{
+  return NONE != status;
+}
+
+bool ObTransferInTransStatus::allow_gc(const ObTransferInTransStatus::STATUS &status)
+{
+  return NONE == status
+      || ABORT == status;
+}
+
+int ObTransferInTransStatus::check_can_change_status(
+    const ObTransferInTransStatus::STATUS &cur_status,
+    const ObTransferInTransStatus::STATUS &change_status,
+    bool &can_change)
+{
+  int ret = OB_SUCCESS;
+  can_change = false;
+  if (!is_valid(cur_status) || !is_valid(change_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("check can change status get invalid argument", K(ret), K(cur_status), K(change_status));
+  } else {
+    switch (cur_status) {
+    case ObTransferInTransStatus::NONE: {
+      if (ObTransferInTransStatus::NONE == change_status
+          || ObTransferInTransStatus::PREPARE == change_status
+          || ObTransferInTransStatus::ABORT == change_status) {
+        can_change = true;
+      }
+      break;
+    }
+    case ObTransferInTransStatus::PREPARE: {
+      if (ObTransferInTransStatus::PREPARE == change_status
+          || ObTransferInTransStatus::NONE == change_status
+          || ObTransferInTransStatus::ABORT == change_status) {
+        can_change = true;
+      }
+      break;
+    }
+    case ObTransferInTransStatus::ABORT: {
+      if (ObTransferInTransStatus::ABORT == change_status
+          || ObTransferInTransStatus::NONE == change_status) {
+        can_change = true;
+      }
+      break;
+    }
+    default: {
+      ret = OB_INVALID_ARGUMENT;
+      LOG_ERROR("invalid cur status for fail", K(ret), K(cur_status), K(change_status));
+    }
+    }
+  }
+  return ret;
+}
+
+ObTransferTabletIDArray::ObTransferTabletIDArray()
+  : count_(0)
+{
+}
+
+ObTransferTabletIDArray::~ObTransferTabletIDArray()
+{
+}
+
+OB_DEF_SERIALIZE(ObTransferTabletIDArray)
+{
+  int ret = OB_SUCCESS;
+  OB_UNIS_ENCODE_ARRAY(id_array_, count_);
+  return ret;
+}
+
+OB_DEF_SERIALIZE_SIZE(ObTransferTabletIDArray)
+{
+  int64_t len = 0;
+  OB_UNIS_ADD_LEN_ARRAY(id_array_, count_);
+  return len;
+}
+
+OB_DEF_DESERIALIZE(ObTransferTabletIDArray)
+{
+  int ret = OB_SUCCESS;
+  int64_t count = 0;
+
+  OB_UNIS_DECODE(count);
+  if (OB_SUCC(ret)) {
+    count_ = count;
+  }
+  OB_UNIS_DECODE_ARRAY(id_array_, count_);
+  return ret;
+}
+
+int ObTransferTabletIDArray::push_back(const common::ObTabletID &tablet_id)
+{
+  int ret = OB_SUCCESS;
+  if (!tablet_id.is_valid()) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("tablet id is invalid", K(ret), K(tablet_id));
+  } else if (count_ >= MAX_TABLET_COUNT) {
+    ret = OB_SIZE_OVERFLOW;
+    LOG_WARN("transfer tablet id array is size overflow", K(ret), K(count_));
+  } else {
+    id_array_[count_] = tablet_id;
+    count_++;
+  }
+  return ret;
+}
+
+int ObTransferTabletIDArray::assign(const common::ObIArray<common::ObTabletID> &tablet_id_array)
+{
+  int ret = OB_SUCCESS;
+  if (tablet_id_array.count() > MAX_TABLET_COUNT) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("cannot assign tablet id array", K(ret), K(tablet_id_array));
+  } else {
+    count_ = 0;
+    for (int64_t i = 0; OB_SUCC(ret) && i < tablet_id_array.count(); ++i) {
+      const common::ObTabletID &tablet_id = tablet_id_array.at(i);
+      if (OB_FAIL(push_back(tablet_id))) {
+        LOG_WARN("failed to push tablet id into array", K(ret));
+      }
+    }
+  }
+  return ret;
+}
+
+int ObTransferTabletIDArray::get_tablet_id_array(
+    common::ObIArray<common::ObTabletID> &tablet_id_array)
+{
+  int ret = OB_SUCCESS;
+  tablet_id_array.reset();
+  for (int64_t i = 0; OB_SUCC(ret) && i < count_; ++i) {
+    if (OB_FAIL(tablet_id_array.push_back(id_array_[i]))) {
+      LOG_WARN("failed to push tablet id into array", K(ret), K(count_), K(i));
+    }
+  }
+  return ret;
+}
+
+
+ObLSTransferMetaInfo::ObLSTransferMetaInfo()
+  : src_ls_(TRANSFER_INIT_LS_ID),
+    src_scn_(share::SCN::base_scn()),
+    trans_status_(ObTransferInTransStatus::NONE),
+    tablet_id_array_(),
+    data_version_(DEFAULT_MIN_DATA_VERSION)
+{
+}
+
+int ObLSTransferMetaInfo::set_transfer_info(
+    const share::ObLSID &src_ls,
+    const share::SCN &src_scn,
+    const ObTransferInTransStatus::STATUS &trans_status,
+    const common::ObIArray<common::ObTabletID> &tablet_id_array,
+    const uint64_t data_version)
+{
+  int ret = OB_SUCCESS;
+  bool can_change = false;
+
+  if (!src_ls.is_valid() || !src_scn.is_valid() || !ObTransferInTransStatus::is_valid(trans_status) || 0 == data_version) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("set transfer info get invalid argument", K(ret), K(src_ls), K(src_scn), K(trans_status), K(data_version));
+  } else if (OB_FAIL(update_trans_status_(trans_status))) {
+    LOG_WARN("failed to update trans status", K(ret), K(trans_status));
+  } else if (OB_FAIL(tablet_id_array_.assign(tablet_id_array))) {
+    LOG_WARN("failed to assign tablet id array", K(ret), K(tablet_id_array));
+  } else {
+    src_ls_ = src_ls;
+    src_scn_ = src_scn;
+    trans_status_ = trans_status;
+    data_version_ = data_version;
+  }
+  return ret;
+}
+
+int ObLSTransferMetaInfo::cleanup_transfer_info()
+{
+  int ret = OB_SUCCESS;
+  bool can_change = false;
+  const ObTransferInTransStatus::STATUS trans_status = ObTransferInTransStatus::NONE;
+
+  if (!is_valid()) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("ls transfer meta info is invalid, unexpected", K(ret), KPC(this));
+  } else if (OB_FAIL(update_trans_status_(trans_status))) {
+    LOG_WARN("failed to update trans status", K(ret), K(trans_status), KPC(this));
+  } else {
+    src_ls_ = TRANSFER_INIT_LS_ID;
+    src_scn_.set_base();
+    tablet_id_array_.reset();
+  }
+  return ret;
+}
+
+int ObLSTransferMetaInfo::update_trans_status(const ObTransferInTransStatus::STATUS &trans_status)
+{
+  int ret = OB_SUCCESS;
+  if (!ObTransferInTransStatus::is_valid(trans_status)) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("update trans status get invalid argument", K(ret), K(trans_status));
+  } else if (OB_FAIL(update_trans_status_(trans_status))) {
+    LOG_WARN("failed to update trans status", K(ret), K(trans_status));
+  }
+  return ret;
+}
+
+void ObLSTransferMetaInfo::reset()
+{
+  src_ls_ = TRANSFER_INIT_LS_ID;
+  src_scn_.set_base();
+  trans_status_ = ObTransferInTransStatus::NONE;
+  tablet_id_array_.reset();
+  data_version_ = 0;
+}
+
+bool ObLSTransferMetaInfo::is_valid() const
+{
+  return src_ls_.is_valid()
+      && src_scn_.is_valid()
+      && ObTransferInTransStatus::is_valid(trans_status_)
+      && data_version_ > 0;
+}
+
+bool ObLSTransferMetaInfo::is_equal(
+    const share::ObLSID &src_ls,
+    const share::SCN &src_scn,
+    const ObTransferInTransStatus::STATUS &trans_status,
+    const ObTransferTabletIDArray &tablet_id_array)
+{
+  bool b_ret = false;
+  if (src_ls_ == src_ls
+      && src_scn_ == src_scn
+      && trans_status_ == trans_status) {
+    b_ret = true;
+  }
+
+  if (b_ret) {
+    if (tablet_id_array_.count() != tablet_id_array.count()) {
+      b_ret = false;
+    } else {
+      for (int64_t i = 0; i < tablet_id_array_.count(); ++i) {
+        if (tablet_id_array_.at(i) != tablet_id_array.at(i)) {
+          b_ret = false;
+          break;
+        }
+      }
+    }
+  }
+  return b_ret;
+}
+
+bool ObLSTransferMetaInfo::is_empty()
+{
+  ObLSID init_ls(TRANSFER_INIT_LS_ID);
+  return src_ls_ == init_ls
+      && src_scn_.is_min()
+      && ObTransferInTransStatus::NONE == trans_status_
+      && tablet_id_array_.empty();
+}
+
+bool ObLSTransferMetaInfo::allow_src_ls_gc()
+{
+  return ObTransferInTransStatus::NONE == trans_status_
+      || ObTransferInTransStatus::ABORT == trans_status_;
+}
+
+bool ObLSTransferMetaInfo::need_check_transfer_tablet()
+{
+  return ObTransferInTransStatus::ABORT == trans_status_
+      || tablet_id_array_.empty();
+}
+
+int ObLSTransferMetaInfo::check_tablet_in_list(
+    const common::ObTabletID &tablet_id,
+    bool &is_exist)
+{
+  int ret = OB_SUCCESS;
+  is_exist = false;
+
+  if (!tablet_id.is_valid()) {
+    ret = OB_INVALID_ARGUMENT;
+    LOG_WARN("check tablet in list get invalid argument", K(ret));
+  } else {
+    for (int64_t i = 0; OB_SUCC(ret) && i < tablet_id_array_.count(); ++i) {
+      if (tablet_id == tablet_id_array_.at(i)) {
+        is_exist = true;
+        break;
+      }
+    }
+  }
+  return ret;
+}
+
+bool ObLSTransferMetaInfo::is_in_trans()
+{
+  return ObTransferInTransStatus::ABORT == trans_status_
+      || ObTransferInTransStatus::PREPARE == trans_status_;
+}
+
+bool ObLSTransferMetaInfo::is_trans_status_same(
+    const ObTransferInTransStatus::STATUS &trans_status)
+{
+  return trans_status_ == trans_status;
+}
+
+bool ObLSTransferMetaInfo::is_abort_status()
+{
+  return ObTransferInTransStatus::ABORT == trans_status_;
+}
+
+int ObLSTransferMetaInfo::update_trans_status_(
+    const ObTransferInTransStatus::STATUS &trans_status)
+{
+  int ret = OB_SUCCESS;
+  bool can_change = false;
+  if (OB_FAIL(ObTransferInTransStatus::check_can_change_status(trans_status_, trans_status, can_change))) {
+    LOG_WARN("failed to check can change status", K(ret), K(trans_status_), K(trans_status));
+  } else if (!can_change) {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("cannot change transfer in trans status", K(ret), K(trans_status_), K(trans_status));
+  } else {
+    trans_status_ = trans_status;
+  }
+  return ret;
+}
+
+int ObLSTransferMetaInfo::get_tablet_id_array(
+    common::ObIArray<ObTabletID> &tablet_id_array)
+{
+  int ret = OB_SUCCESS;
+  tablet_id_array.reset();
+  if (OB_FAIL(tablet_id_array_.get_tablet_id_array(tablet_id_array))) {
+    LOG_WARN("failed to get tablet id array", K(ret), K(tablet_id_array_));
+  }
+  return ret;
+}
+
+bool ObLSTransferMetaInfo::is_in_compatible_status()
+{
+  return data_version_ < MOCK_DATA_VERSION_4_2_3_0;
+}
+
+int64_t ObLSTransferMetaInfo::to_string(char *buf, const int64_t buf_len) const
+{
+  int ret = OB_SUCCESS;
+  int64_t pos = 0;
+  int64_t save_pos = 0;
+  if (OB_ISNULL(buf) || buf_len <= 0) {
+      // do nothing
+  } else {
+    ObClusterVersion data_version;
+    if (OB_FAIL(data_version.init(data_version_))) {
+      LOG_WARN("failed to init data version", K(ret), K(data_version_));
+    } else {
+      J_OBJ_START();
+      J_KV(K_(src_ls), K_(src_scn), K_(trans_status), K_(tablet_id_array), K(data_version));
+      J_OBJ_END();
+    }
+  }
+  return pos;
+}
+
+OB_SERIALIZE_MEMBER(ObLSTransferMetaInfo, src_ls_, src_scn_, trans_status_, tablet_id_array_, data_version_);
--- a/src/storage/high_availability/ob_ls_transfer_info.h
+++ b/src/storage/high_availability/ob_ls_transfer_info.h
@ -16,6 +16,7 @@
 #include "share/ob_define.h"
 #include "lib/utility/ob_unify_serialize.h"
 #include "share/scn.h"
+#include "lib/container/ob_array_serialization.h"

 namespace oceanbase
 {
@ -24,7 +25,6 @@ namespace storage

 struct ObLSTransferInfo final
 {
-  OB_UNIS_VERSION(1);
 public:
  ObLSTransferInfo();
  ~ObLSTransferInfo() = default;
@ -43,6 +43,116 @@ private:
  static const int64_t TRANSFER_INIT_LS_ID = 0;
 };

+class ObTransferInTransStatus final
+{
+public:
+  enum STATUS : uint8_t
+  {
+    NONE = 0,
+    PREPARE = 1,
+    ABORT = 2,
+    MAX
+  };
+public:
+  ObTransferInTransStatus() = default;
+  ~ObTransferInTransStatus() = default;
+public:
+  static bool is_valid(const ObTransferInTransStatus::STATUS &status);
+  static bool can_skip_barrier(const ObTransferInTransStatus::STATUS &status);
+  static bool allow_gc(const ObTransferInTransStatus::STATUS &status);
+  static int check_can_change_status(
+      const ObTransferInTransStatus::STATUS &cur_status,
+      const ObTransferInTransStatus::STATUS &change_status,
+      bool &can_change);
+};
+
+struct ObTransferTabletIDArray final
+{
+  OB_UNIS_VERSION(1);
+public:
+  ObTransferTabletIDArray();
+  ~ObTransferTabletIDArray();
+  int assign(const common::ObIArray<common::ObTabletID> &tablet_id_array);
+  int push_back(const common::ObTabletID &tablet_id);
+  int get_tablet_id_array(common::ObIArray<common::ObTabletID> &tablet_id_array);
+
+  inline const common::ObTabletID &at(int64_t idx) const
+  {
+    OB_ASSERT(idx >= 0 && idx < count_);
+    return id_array_[idx];
+  }
+  inline common::ObTabletID &at(int64_t idx)
+  {
+    OB_ASSERT(idx >= 0 && idx < count_);
+    return id_array_[idx];
+  }
+  inline int64_t count() const { return count_; }
+  inline bool empty() const { return 0 == count(); }
+  void reset() { count_ = 0; }
+
+  int64_t to_string(char* buf, const int64_t buf_len) const
+  {
+    int64_t pos = 0;
+    J_OBJ_START();
+    J_NAME("id_array");
+    J_COLON();
+    (void)databuff_print_obj_array(buf, buf_len, pos, id_array_, count_);
+    J_OBJ_END();
+    return pos;
+  }
+private:
+  static const int64_t MAX_TABLET_COUNT = 200;
+  int64_t count_;
+  common::ObTabletID id_array_[MAX_TABLET_COUNT];
+};
+
+struct ObLSTransferMetaInfo final
+{
+  OB_UNIS_VERSION(1);
+public:
+  ObLSTransferMetaInfo();
+  ~ObLSTransferMetaInfo() = default;
+  int set_transfer_info(
+      const share::ObLSID &src_ls,
+      const share::SCN &src_scn,
+      const ObTransferInTransStatus::STATUS &trans_status,
+      const common::ObIArray<common::ObTabletID> &tablet_id_array,
+      const uint64_t data_version);
+  int cleanup_transfer_info();
+  int update_trans_status(const ObTransferInTransStatus::STATUS &trans_status);
+
+  void reset();
+  bool is_valid() const;
+  bool is_equal(
+      const share::ObLSID &src_ls,
+      const share::SCN &src_scn,
+      const ObTransferInTransStatus::STATUS &trans_status,
+      const ObTransferTabletIDArray &tablet_id_array);
+  bool is_empty();
+  bool allow_src_ls_gc();
+  bool need_check_transfer_tablet();
+  int check_tablet_in_list(
+      const common::ObTabletID &tablet_id,
+      bool &is_exist);
+  bool is_in_trans();
+  bool is_trans_status_same(const ObTransferInTransStatus::STATUS &trans_status);
+  bool is_abort_status();
+  int get_tablet_id_array(common::ObIArray<ObTabletID> &tablet_id_array);
+  bool is_in_compatible_status();
+  int64_t to_string(char *buf, const int64_t buf_len) const;
+
+private:
+  int update_trans_status_(const ObTransferInTransStatus::STATUS &trans_status);
+
+public:
+  share::ObLSID src_ls_;
+  share::SCN src_scn_;  //transfer start scn
+  ObTransferInTransStatus::STATUS trans_status_;
+  ObTransferTabletIDArray tablet_id_array_;
+  uint64_t data_version_;
+private:
+  static const int64_t TRANSFER_INIT_LS_ID = 0;
+};

 }
 }
--- a/src/storage/high_availability/ob_transfer_struct.cpp
+++ b/src/storage/high_availability/ob_transfer_struct.cpp
@ -31,7 +31,8 @@ ObTXStartTransferOutInfo::ObTXStartTransferOutInfo()
    dest_ls_id_(),
    tablet_list_(),
    task_id_(),
-    data_end_scn_()
+    data_end_scn_(),
+    data_version_(DEFAULT_MIN_DATA_VERSION)
 {
 }

@ -66,18 +67,20 @@ int ObTXStartTransferOutInfo::assign(const ObTXStartTransferOutInfo &start_trans
    task_id_ = start_transfer_out_info.task_id_;
    data_end_scn_ = start_transfer_out_info.data_end_scn_;
    transfer_epoch_ = start_transfer_out_info.transfer_epoch_;
+    data_version_ = start_transfer_out_info.data_version_;
  }
  return ret;
 }

-OB_SERIALIZE_MEMBER(ObTXStartTransferOutInfo, src_ls_id_, dest_ls_id_, tablet_list_, task_id_, data_end_scn_, transfer_epoch_);
+OB_SERIALIZE_MEMBER(ObTXStartTransferOutInfo, src_ls_id_, dest_ls_id_, tablet_list_, task_id_, data_end_scn_, transfer_epoch_, data_version_);

 ObTXStartTransferInInfo::ObTXStartTransferInInfo()
  : src_ls_id_(),
    dest_ls_id_(),
    start_scn_(),
    tablet_meta_list_(),
-    task_id_()
+    task_id_(),
+    data_version_(DEFAULT_MIN_DATA_VERSION)
 {
 }

@ -88,6 +91,7 @@ void ObTXStartTransferInInfo::reset()
  start_scn_.reset();
  tablet_meta_list_.reset();
  task_id_.reset();
+  data_version_ = 0;
 }

 bool ObTXStartTransferInInfo::is_valid() const
@ -111,21 +115,23 @@ int ObTXStartTransferInInfo::assign(const ObTXStartTransferInInfo &start_transfe
    dest_ls_id_ = start_transfer_in_info.dest_ls_id_;
    start_scn_ = start_transfer_in_info.start_scn_;
    task_id_ = start_transfer_in_info.task_id_;
+    data_version_ = start_transfer_in_info.data_version_;
  }
  return ret;
 }

-OB_SERIALIZE_MEMBER(ObTXStartTransferInInfo, src_ls_id_, dest_ls_id_, start_scn_, tablet_meta_list_, task_id_);
+OB_SERIALIZE_MEMBER(ObTXStartTransferInInfo, src_ls_id_, dest_ls_id_, start_scn_, tablet_meta_list_, task_id_, data_version_);

 /* ObTXFinishTransferInInfo */

-OB_SERIALIZE_MEMBER(ObTXFinishTransferInInfo, src_ls_id_, dest_ls_id_, start_scn_, tablet_list_, task_id_);
+OB_SERIALIZE_MEMBER(ObTXFinishTransferInInfo, src_ls_id_, dest_ls_id_, start_scn_, tablet_list_, task_id_, data_version_);
 ObTXFinishTransferInInfo::ObTXFinishTransferInInfo()
  : src_ls_id_(),
    dest_ls_id_(),
    start_scn_(),
    tablet_list_(),
-    task_id_()
+    task_id_(),
+    data_version_(DEFAULT_MIN_DATA_VERSION)
 {
 }

@ -136,6 +142,7 @@ void ObTXFinishTransferInInfo::reset()
  start_scn_.reset();
  tablet_list_.reset();
  task_id_.reset();
+  data_version_ = 0;
 }

 bool ObTXFinishTransferInInfo::is_valid() const
@ -159,18 +166,20 @@ int ObTXFinishTransferInInfo::assign(const ObTXFinishTransferInInfo &finish_tran
    dest_ls_id_ = finish_transfer_in_info.dest_ls_id_;
    start_scn_ = finish_transfer_in_info.start_scn_;
    task_id_ = finish_transfer_in_info.task_id_;
+    data_version_ = finish_transfer_in_info.data_version_;
  }
  return ret;
 }

 /* ObTXFinishTransferOutInfo */
-OB_SERIALIZE_MEMBER(ObTXFinishTransferOutInfo, src_ls_id_, dest_ls_id_, finish_scn_, tablet_list_, task_id_);
+OB_SERIALIZE_MEMBER(ObTXFinishTransferOutInfo, src_ls_id_, dest_ls_id_, finish_scn_, tablet_list_, task_id_, data_version_);
 ObTXFinishTransferOutInfo::ObTXFinishTransferOutInfo()
  : src_ls_id_(),
    dest_ls_id_(),
    finish_scn_(),
    tablet_list_(),
-    task_id_()
+    task_id_(),
+    data_version_(DEFAULT_MIN_DATA_VERSION)
 {
 }
 void ObTXFinishTransferOutInfo::reset()
@ -180,6 +189,7 @@ void ObTXFinishTransferOutInfo::reset()
  finish_scn_.reset();
  tablet_list_.reset();
  task_id_.reset();
+  data_version_ = 0;
 }
 bool ObTXFinishTransferOutInfo::is_valid() const
 {
@ -202,6 +212,7 @@ int ObTXFinishTransferOutInfo::assign(const ObTXFinishTransferOutInfo &finish_tr
    dest_ls_id_ = finish_transfer_out_info.dest_ls_id_;
    finish_scn_ = finish_transfer_out_info.finish_scn_;
    task_id_ = finish_transfer_out_info.task_id_;
+    data_version_ = finish_transfer_out_info.data_version_;
  }
  return ret;
 }
--- a/src/storage/high_availability/ob_transfer_struct.h
+++ b/src/storage/high_availability/ob_transfer_struct.h
@ -37,7 +37,7 @@ public:
  bool is_valid() const;
  int assign(const ObTXStartTransferOutInfo &start_transfer_out_info);

-  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(tablet_list), K_(task_id), K_(data_end_scn), K_(transfer_epoch));
+  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(tablet_list), K_(task_id), K_(data_end_scn), K_(transfer_epoch), K_(data_version));

  share::ObLSID src_ls_id_;
  share::ObLSID dest_ls_id_;
@ -45,6 +45,7 @@ public:
  share::ObTransferTaskID task_id_;
  share::SCN data_end_scn_;
  int64_t transfer_epoch_;
+  uint64_t data_version_;  //transfer_dml_ctrl_42x # placeholder
  DISALLOW_COPY_AND_ASSIGN(ObTXStartTransferOutInfo);
 };

@ -58,13 +59,14 @@ public:
  bool is_valid() const;
  int assign(const ObTXStartTransferInInfo &start_transfer_in_info);

-  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(start_scn), K_(tablet_meta_list), K_(task_id));
+  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(start_scn), K_(tablet_meta_list), K_(task_id), K_(data_version));

  share::ObLSID src_ls_id_;
  share::ObLSID dest_ls_id_;
  share::SCN start_scn_;
  common::ObSArray<ObMigrationTabletParam> tablet_meta_list_;
  share::ObTransferTaskID task_id_;
+  uint64_t data_version_; //transfer_dml_ctrl_42x # placeholder

  DISALLOW_COPY_AND_ASSIGN(ObTXStartTransferInInfo);
 };
@ -79,12 +81,13 @@ public:
  bool is_valid() const;
  int assign(const ObTXFinishTransferOutInfo &finish_transfer_out_info);

-  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(finish_scn), K_(tablet_list), K_(task_id));
+  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(finish_scn), K_(tablet_list), K_(task_id), K_(data_version));
  share::ObLSID src_ls_id_;
  share::ObLSID dest_ls_id_;
  share::SCN finish_scn_;
  common::ObSArray<share::ObTransferTabletInfo> tablet_list_;
  share::ObTransferTaskID task_id_;
+  uint64_t data_version_;  //transfer_dml_ctrl_42x # placeholder
  DISALLOW_COPY_AND_ASSIGN(ObTXFinishTransferOutInfo);
 };

@ -98,12 +101,13 @@ public:
  bool is_valid() const;
  int assign(const ObTXFinishTransferInInfo &finish_transfer_in_info);

-  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(start_scn), K_(tablet_list), K_(task_id));
+  TO_STRING_KV(K_(src_ls_id), K_(dest_ls_id), K_(start_scn), K_(tablet_list), K_(task_id), K_(data_version));
  share::ObLSID src_ls_id_;
  share::ObLSID dest_ls_id_;
  share::SCN start_scn_;
  common::ObSArray<share::ObTransferTabletInfo> tablet_list_;
  share::ObTransferTaskID task_id_;
+  uint64_t data_version_;  //transfer_dml_ctrl_42x # placeholder
  DISALLOW_COPY_AND_ASSIGN(ObTXFinishTransferInInfo);
 };

@ -177,6 +181,7 @@ public:
  {
    START = 0,
    DOING = 1,
+    ABORTED = 2, //transfer_dml_ctrl_42x # placeholder
    MAX_STATUS
  };
 public:
--- a/src/storage/ls/ob_ls_meta.cpp
+++ b/src/storage/ls/ob_ls_meta.cpp
@ -62,7 +62,8 @@ ObLSMeta::ObLSMeta()
    all_id_meta_(),
    saved_info_(),
    transfer_scn_(SCN::min_scn()),
-    rebuild_info_()
+    rebuild_info_(),
+    transfer_meta_info_()
 {
 }

@ -83,7 +84,8 @@ ObLSMeta::ObLSMeta(const ObLSMeta &ls_meta)
    tablet_change_checkpoint_scn_(ls_meta.tablet_change_checkpoint_scn_),
    saved_info_(ls_meta.saved_info_),
    transfer_scn_(ls_meta.transfer_scn_),
-    rebuild_info_(ls_meta.rebuild_info_)
+    rebuild_info_(ls_meta.rebuild_info_),
+    transfer_meta_info_(ls_meta.transfer_meta_info_)
 {
  all_id_meta_.update_all_id_meta(ls_meta.all_id_meta_);
 }
@ -139,6 +141,7 @@ ObLSMeta &ObLSMeta::operator=(const ObLSMeta &other)
    saved_info_ = other.saved_info_;
    transfer_scn_ = other.transfer_scn_;
    rebuild_info_ = other.rebuild_info_;
+    transfer_meta_info_ = other.transfer_meta_info_;
  }
  return *this;
 }
@ -161,6 +164,7 @@ void ObLSMeta::reset()
  saved_info_.reset();
  transfer_scn_ = SCN::min_scn();
  rebuild_info_.reset();
+  transfer_meta_info_.reset();
 }

 LSN &ObLSMeta::get_clog_base_lsn()
@ -517,6 +521,7 @@ int ObLSMeta::update_ls_meta(
      if (update_restore_status) {
        restore_status_ = ls_restore_status;
      }
+      transfer_meta_info_ = src_ls_meta.transfer_meta_info_;
    }
    LOG_INFO("update ls meta", K(ret), K(tmp), K(src_ls_meta), K(*this));
  }
@ -940,7 +945,8 @@ OB_SERIALIZE_MEMBER(ObLSMeta,
                    all_id_meta_,
                    saved_info_,
                    transfer_scn_,
-                    rebuild_info_);
+                    rebuild_info_,
+                    transfer_meta_info_);

 }
 }
--- a/src/storage/ls/ob_ls_meta.h
+++ b/src/storage/ls/ob_ls_meta.h
@ -28,6 +28,7 @@
 #include "storage/tx/ob_id_service.h"
 #include "storage/ls/ob_ls_saved_info.h"
 #include "share/scn.h"
+#include "storage/high_availability/ob_ls_transfer_info.h"

 namespace oceanbase
 {
@ -159,7 +160,7 @@ public:
               K_(clog_checkpoint_scn), K_(clog_base_lsn),
               K_(rebuild_seq), K_(migration_status), K(gc_state_), K(offline_scn_),
               K_(restore_status), K_(replayable_point), K_(tablet_change_checkpoint_scn),
-               K_(all_id_meta), K_(transfer_scn), K_(rebuild_info));
+               K_(all_id_meta), K_(transfer_scn), K_(rebuild_info), K_(transfer_meta_info));
 private:
  int check_can_update_();
 public:
@ -199,6 +200,7 @@ private:
  ObLSSavedInfo saved_info_;
  share::SCN transfer_scn_;
  ObLSRebuildInfo rebuild_info_;
+  ObLSTransferMetaInfo transfer_meta_info_; //transfer_dml_ctrl_42x # placeholder
 };

 }  // namespace storage