refactor: remove unused code (#418)

Clean the code and remove unused codes,
or these unused codes would confuse our developers.

deps/oblib/src/common/CMakeLists.txt

@@ -2,7 +2,6 @@ ob_set_subtarget(oblib_common common
   cell/ob_cell_reader.cpp
   cell/ob_cell_writer.cpp
   data_buffer.cpp
-  lease/ob_lease_common.cpp
   log/ob_direct_log_reader.cpp
   log/ob_log_cursor.cpp
   log/ob_log_data_writer.cpp

deps/oblib/src/common/lease/ob_lease_common.cpp

-/**
- * 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 "common/lease/ob_lease_common.h"
-#include "lib/oblog/ob_log.h"
-
-namespace oceanbase {
-using namespace lib;
-
-namespace common {
-bool ObLease::is_lease_valid(int64_t redun_time)
-{
-  bool ret = true;
-
-  timeval time_val;
-  (void)gettimeofday(&time_val, NULL);
-  int64_t cur_time_us = time_val.tv_sec * 1000 * 1000 + time_val.tv_usec;
-  if (lease_time + lease_interval + redun_time < cur_time_us) {
-    _OB_LOG(INFO,
-        "Lease expired, lease_time=%ld, lease_interval=%ld, cur_time_us=%ld",
-        lease_time,
-        lease_interval,
-        cur_time_us);
-    ret = false;
-  }
-
-  return ret;
-}
-
-DEFINE_SERIALIZE(ObLease)
-{
-  int err = OB_SUCCESS;
-  if (NULL == buf || buf_len <= 0 || pos < 0) {
-    _OB_LOG(WARN, "invalid param, buf=%p, buf_len=%ld, pos=%ld", buf, buf_len, pos);
-    err = OB_INVALID_ARGUMENT;
-  } else if (pos + (int64_t)sizeof(*this) > buf_len) {
-    _OB_LOG(WARN, "buf is not enough, pos=%ld, buf_len=%ld", pos, buf_len);
-    err = OB_INVALID_ARGUMENT;
-  } else {
-    *((ObLease*)(buf + pos)) = *this;
-    pos += sizeof(*this);
-  }
-
-  return err;
-}
-
-DEFINE_DESERIALIZE(ObLease)
-{
-  int err = OB_SUCCESS;
-  if (NULL == buf || data_len <= 0 || pos < 0) {
-    _OB_LOG(WARN, "invalid param, buf=%p, data_len=%ld, pos=%ld", buf, data_len, pos);
-    err = OB_INVALID_ARGUMENT;
-  } else if (pos + (int64_t)sizeof(*this) > data_len) {
-    _OB_LOG(WARN, "data_len is not enough, pos=%ld, data_len=%ld", pos, data_len);
-    err = OB_INVALID_ARGUMENT;
-  } else {
-    *this = *((ObLease*)(buf + pos));
-    pos += sizeof(*this);
-  }
-
-  return err;
-}
-
-DEFINE_GET_SERIALIZE_SIZE(ObLease)
-{
-  return sizeof(*this);
-}
-}  // namespace common
-}  // namespace oceanbase

deps/oblib/src/common/lease/ob_lease_common.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.
- */
-
-#ifndef __OCEANBASE_COMMON_OB_LEASE_COMMON_H__
-#define __OCEANBASE_COMMON_OB_LEASE_COMMON_H__
-#include "lib/ob_define.h"
-
-namespace oceanbase {
-namespace common {
-struct ObLease {
-  int64_t lease_time;      // lease start time
-  int64_t lease_interval;  // lease interval, lease valid time [lease_time, lease_time + lease_interval]
-  int64_t renew_interval;  // renew interval, slave will renew lease when lease expiration time is close
-
-  ObLease() : lease_time(0), lease_interval(0), renew_interval(0)
-  {}
-
-  bool is_lease_valid(int64_t redun_time);
-
-  NEED_SERIALIZE_AND_DESERIALIZE;
-};
-}  // namespace common
-}  // namespace oceanbase
-
-#endif  //__OCEANBASE_COMMON_OB_LEASE_COMMON_H__

deps/oblib/src/lib/cbtree/btree_varchar_key.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.
- */
-
-#ifndef __CBTREE_BTREE_VARCHAR_KEY_H__
-#define __CBTREE_BTREE_VARCHAR_KEY_H__
-
-#include "lib/cbtree/btree.h"
-
-namespace cbtree {
-inline int cbt_memcmp(const char* s1_, const char* s2_, int limit, int& offset)
-{
-  int cmp = 0;
-  unsigned char* s1 = (unsigned char*)s1_;
-  unsigned char* s2 = (unsigned char*)s2_;
-  while (offset < limit && (cmp = (*s1++ - *s2++)) == 0) {
-    offset++;
-  }
-  return cmp;
-}
-
-inline int cbt_memcmp_with_prefix(
-    const char* s1, const char* s2, const char* prefix, int prefix_len, int limit, int& offset)
-{
-  return cbt_memcmp(s1, prefix, prefix_len, offset) ?: cbt_memcmp(s1 + offset, s2 + offset, limit, offset);
-}
-
-struct VarCharBuffer {
-  VarCharBuffer() : len_(0)
-  {}
-  ~VarCharBuffer()
-  {}
-  int get_total_len() const
-  {
-    return len_ + (int)sizeof(*this);
-  }
-  static uint16_t min(uint16_t x1, uint16_t x2)
-  {
-    return x1 < x2 ? x1 : x2;
-  }
-  uint16_t len_;
-  char buf_[0];
-  inline int compare(const VarCharBuffer& that, int& offset) const
-  {
-    return cbt_memcmp(this->buf_, that.buf_, min(this->len_, that.len_), offset) ?: this->len_ - that.len_;
-  }
-};
-
-struct VarCharKey {
-  typedef VarCharKey key_t;
-  enum { OFFSET_MASK = (1 << 13) - 1, SUFFIX_LEN_MASK = (1 << 3) - 1 };
-  struct comp_helper_t {
-    comp_helper_t() : last_decided_offset_(-1)
-    {}
-    void reset()
-    {
-      last_decided_offset_ = -1;
-    }
-    void reset_diff(key_t& key)
-    {
-      key.diff_offset_ = key.key_->len_ & OFFSET_MASK;
-      key.diff_suffix_len_ = 0 & SUFFIX_LEN_MASK;
-    }
-    void calc_diff(key_t& thiskey, const key_t that)
-    {
-      int offset = 0;
-      thiskey.key_->compare(*that.key_, offset);
-      thiskey.diff_offset_ = offset & OFFSET_MASK;
-      MEMCPY(thiskey.diff_suffix_,
-          thiskey.key_->buf_ + offset,
-          VarCharBuffer::min((uint16_t)sizeof(thiskey.diff_suffix_), (uint16_t)(thiskey.key_->len_ - offset)));
-    }
-    bool ideq(const key_t& key1, const key_t& key2) const
-    {
-      return key1.key_ == key2.key_;
-    }
-    bool veq(const key_t& key1, const key_t& key2) const
-    {
-      return key1.compare(key2) == 0;
-    }
-    int compare(const key_t& key1, const key_t& key2) const
-    {
-      return key1.compare(key2);
-    }
-    int linear_search_compare(const key_t search_key, const key_t idx_key)
-    {
-      int cmp = 0;
-      int decided_offset = 0;
-      if (last_decided_offset_ < 0) {
-        if ((cmp = search_key.key_->compare(*idx_key.key_, decided_offset)) >= 0) {
-          last_decided_offset_ = decided_offset;
-        }
-      } else if (idx_key.diff_offset_ > last_decided_offset_) {
-        cmp = 1;
-      } else if ((cmp = (cbt_memcmp_with_prefix(search_key.key_->buf_ + idx_key.diff_offset_,
-                             idx_key.key_->buf_ + idx_key.diff_offset_,
-                             idx_key.diff_suffix_,
-                             idx_key.diff_suffix_len_,
-                             VarCharBuffer::min(search_key.key_->len_, idx_key.key_->len_) - idx_key.diff_offset_,
-                             decided_offset)
-                             ?: search_key.key_->len_ - idx_key.key_->len_)) >= 0) {
-        last_decided_offset_ = idx_key.diff_offset_ + decided_offset;
-      }
-      return cmp;
-    }
-    int last_decided_offset_;
-  };
-  VarCharKey() : diff_offset_(0), diff_suffix_len_(0), key_(0)
-  {}
-  ~VarCharKey()
-  {}
-  inline int compare(const VarCharKey& key) const
-  {
-    int offset = 0;
-    return key_->compare(*key.key_, offset);
-  }
-  uint16_t diff_offset_ : 13;
-  uint16_t diff_suffix_len_ : 3;
-  char diff_suffix_[6];
-  VarCharBuffer* key_;
-};
-};     // namespace cbtree
-#endif /* __CBTREE_BTREE_VARCHAR_KEY_H__ */

src/storage/flashback/ob_flashback_engine.cpp

-/**
- * 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 "ob_flashback_engine.h"
-#include "clog/ob_log_define.h"
-
-namespace oceanbase {
-namespace storage {
-
-// 1000 -> 500, 1300 -> 700
-// data between 500 and 700 is visible
-bool ObFlashBackEngine::can_skip_version(
-    const int64_t snapshot_version, const int64_t trans_version, ObFlashBackInfoArray* flashback_infos)
-{
-  bool can_skip = false;
-  if (NULL != flashback_infos) {
-    for (int64_t i = flashback_infos->count() - 1; i >= 0; i--) {
-      if (snapshot_version < flashback_infos->at(i).from_) {
-        continue;
-      } else {
-        if (trans_version > flashback_infos->at(i).from_) {
-          can_skip = false;
-          break;
-        } else if (trans_version > flashback_infos->at(i).to_) {
-          can_skip = true;
-          break;
-        }
-      }
-    }
-  }
-  return can_skip;
-}
-
-int ObFlashBackEngine::push_flashback_info(ObFlashBackInfo& flashback_info)
-{
-  int ret = OB_SUCCESS;
-  if (OB_FAIL(flashback_infos_.push_back(flashback_info))) {
-    STORAGE_LOG(WARN, "failed to assign flashback infos", K(ret), K(flashback_info));
-  }
-  STORAGE_LOG(INFO, "push flashback infos", K(flashback_info), K(flashback_infos_));
-  return ret;
-}
-
-int ObFlashBackEngine::set_flashback_infos(ObFlashBackInfoArray& flashback_infos)
-{
-  int ret = OB_SUCCESS;
-  if (OB_FAIL(flashback_infos_.assign(flashback_infos))) {
-    STORAGE_LOG(WARN, "failed to assign flashback infos", K(ret), K(flashback_infos));
-  }
-  return ret;
-}
-
-int ObFlashBackEngine::get_flashback_infos(ObFlashBackInfoArray& flashback_infos)
-{
-  int ret = OB_SUCCESS;
-  if (OB_FAIL(flashback_infos.assign(flashback_infos_))) {
-    STORAGE_LOG(WARN, "failed to assign flashback infos", K(ret), K_(flashback_infos));
-  }
-  return ret;
-}
-
-ObFlashBackPartitionCb::ObFlashBackPartitionCb()
-    : guard_(), flashback_info_(), write_clog_state_(CB_INIT), is_locking_(false)
-{}
-
-void ObFlashBackPartitionCb::reset()
-{
-  guard_.reset();
-  write_clog_state_ = CB_INIT;
-  is_locking_ = false;
-}
-
-int ObFlashBackPartitionCb::init(
-    ObIPartitionGroup* partition_group, ObPartitionService& partition_service, const ObFlashBackInfo& flashback_info)
-{
-  int ret = OB_SUCCESS;
-  guard_.set_partition_group(partition_service.get_pg_mgr(), *partition_group);
-  flashback_info_ = flashback_info;
-  return ret;
-}
-
-int ObFlashBackPartitionCb::on_success(const common::ObPartitionKey& pkey, const clog::ObLogType log_type,
-    const uint64_t log_id, const int64_t version, const bool batch_committed, const bool batch_last_succeed)
-{
-  int ret = OB_SUCCESS;
-  UNUSED(pkey);
-  UNUSED(log_type);
-  UNUSED(version);
-  UNUSED(batch_committed);
-  UNUSED(batch_last_succeed);
-  if (FALSE_IT(flashback_info_.log_id_ = log_id)) {
-  } else if (OB_FAIL(guard_.get_partition_group()->update_flashback_info(flashback_info_))) {
-    STORAGE_LOG(WARN, "failed to flashback", K(ret), K(pkey), K_(flashback_info));
-  } else {
-    bool need_release = false;
-    while (true) {
-      if (false == ATOMIC_TAS(&is_locking_, true)) {
-        if (CB_END != write_clog_state_) {
-          write_clog_state_ = CB_SUCCESS;
-        } else {
-          // rs wait thread has exited, can release memory
-          need_release = true;
-        }
-        ATOMIC_STORE(&is_locking_, false);
-        break;
-      }
-    }
-    if (need_release) {
-      op_free(this);
-    }
-  }
-
-  return ret;
-}
-
-int ObFlashBackPartitionCb::on_finished(const common::ObPartitionKey& pkey, const uint64_t log_id)
-{
-  UNUSED(pkey);
-  UNUSED(log_id);
-  int ret = OB_SUCCESS;
-  // lock
-  bool need_release = false;
-  while (true) {
-    if (false == ATOMIC_TAS(&is_locking_, true)) {
-      if (CB_END != write_clog_state_) {
-        write_clog_state_ = CB_FAIL;
-      } else {
-        // index_builder wait thread has exited, can release memory
-        need_release = true;
-      }
-      ATOMIC_STORE(&is_locking_, false);
-      break;
-    }
-  }
-  if (need_release) {
-    op_free(this);
-  }
-
-  return ret;
-}
-
-int ObFlashBackPartitionCb::check_can_release(bool& can_release)
-{
-  int ret = OB_SUCCESS;
-  // lock
-  while (true) {
-    if (false == ATOMIC_TAS(&is_locking_, true)) {
-      // clog is not callbacked
-      if (CB_FAIL != write_clog_state_ && CB_SUCCESS != write_clog_state_) {
-        write_clog_state_ = CB_END;
-        can_release = false;
-      } else {
-        can_release = true;
-      }
-      ATOMIC_STORE(&is_locking_, false);
-      break;
-    }
-  }
-
-  return ret;
-}
-
-ObFlashBackPartitionCb* ObFlashBackPartitionCbFactory::alloc()
-{
-  return op_reclaim_alloc(ObFlashBackPartitionCb);
-}
-
-void ObFlashBackPartitionCbFactory::release(ObFlashBackPartitionCb* cb)
-{
-  if (NULL != cb) {
-    cb->reset();
-    op_reclaim_free(cb);
-    cb = NULL;
-  }
-}
-
-}  // namespace storage
-}  // namespace oceanbase