hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

ObTableFlag split to ObTableBackFlag and ObTableSharedFlag

Browse Source
This commit is contained in:
godyangfight 2024-08-21 07:48:24 +00:00 committed by ob-robot
parent b263784bf1
commit c6abadd8cf
18 changed files with 236 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mittest/mtlenv/storage/blocksstable/test_index_dumper.cpp
View File

@ -383,8 +383,8 @@ TEST_F(TestIndexDumper, get_from_disk)
}
}
// close
ObTableFlag table_flag;
table_flag.clear();
ObTableBackupFlag table_backup_flag;
table_backup_flag.clear();
ASSERT_EQ(OB_SUCCESS, macro_meta_dumper.close(meta_block_info));
STORAGE_LOG(INFO, "test print meta block info", K(meta_block_info));
ASSERT_FALSE(meta_block_info.in_mem_);

76
mittest/mtlenv/storage/blocksstable/test_index_tree.cpp
View File

@ -668,8 +668,8 @@ void TestIndexTree::mock_compaction(const int64_t test_row_num,
ASSERT_EQ(sec_blk.original_size_, sec_blk.data_zsize_);
ASSERT_EQ(OB_SUCCESS, data_writer.close());
ASSERT_EQ(OB_SUCCESS, sstable_builder->close(res));
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(true, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(true, res.table_backup_flag_.has_local());
ObSSTableMergeRes tmp_res;
ASSERT_EQ(OB_ERR_UNEXPECTED, data_writer.close()); // not re-entrant
@ -677,8 +677,8 @@ void TestIndexTree::mock_compaction(const int64_t test_row_num,
ASSERT_EQ(tmp_res.root_desc_.buf_, res.root_desc_.buf_);
ASSERT_EQ(tmp_res.data_root_desc_.buf_, res.data_root_desc_.buf_);
ASSERT_EQ(tmp_res.data_blocks_cnt_, res.data_blocks_cnt_);
ASSERT_EQ(false, tmp_res.table_flag_.has_backup());
ASSERT_EQ(true, tmp_res.table_flag_.has_local());
ASSERT_EQ(false, tmp_res.table_backup_flag_.has_backup());
ASSERT_EQ(true, tmp_res.table_backup_flag_.has_local());
OK(data_write_ctxs.push_back(sstable_builder->roots_[0]->data_write_ctx_));
roots = &(sstable_builder->roots_);
@ -802,8 +802,8 @@ void TestIndexTree::mock_cg_compaction(const int64_t test_row_num,
ASSERT_EQ(sec_blk.original_size_, sec_blk.data_zsize_);
ASSERT_EQ(OB_SUCCESS, data_writer.close());
ASSERT_EQ(OB_SUCCESS, sstable_builder->close(res));
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(true, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(true, res.table_backup_flag_.has_local());
ObSSTableMergeRes tmp_res;
ASSERT_EQ(OB_ERR_UNEXPECTED, data_writer.close()); // not re-entrant
@ -811,8 +811,8 @@ void TestIndexTree::mock_cg_compaction(const int64_t test_row_num,
ASSERT_EQ(tmp_res.root_desc_.buf_, res.root_desc_.buf_);
ASSERT_EQ(tmp_res.data_root_desc_.buf_, res.data_root_desc_.buf_);
ASSERT_EQ(tmp_res.data_blocks_cnt_, res.data_blocks_cnt_);
ASSERT_EQ(false, tmp_res.table_flag_.has_backup());
ASSERT_EQ(true, tmp_res.table_flag_.has_local());
ASSERT_EQ(false, tmp_res.table_backup_flag_.has_backup());
ASSERT_EQ(true, tmp_res.table_backup_flag_.has_local());
OK(data_write_ctxs.push_back(sstable_builder->roots_[0]->data_write_ctx_));
roots = &(sstable_builder->roots_);
@ -991,8 +991,8 @@ TEST_F(TestIndexTree, test_empty_index_tree)
ASSERT_EQ(0, sstable_builder.roots_.count());
ASSERT_EQ(OB_SUCCESS, ret);
ASSERT_TRUE(res.root_desc_.is_empty());
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(false, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(false, res.table_backup_flag_.has_local());
// test rebuild macro blocks
ASSERT_EQ(OB_SUCCESS, data_writer.open(data_desc.get_desc(), data_seq));
@ -1006,8 +1006,8 @@ TEST_F(TestIndexTree, test_empty_index_tree)
ret = sstable_builder.close(res);
ASSERT_EQ(OB_SUCCESS, ret);
ASSERT_TRUE(res.root_desc_.is_empty());
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(false, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(false, res.table_backup_flag_.has_local());
// test easy index tree
ObDatumRow row;
@ -1130,8 +1130,8 @@ TEST_F(TestIndexTree, test_multi_writers_with_close)
res.reset();
sstable_builder.index_block_loader_.reset();
OK(sstable_builder.close(res));
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(true, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(true, res.table_backup_flag_.has_local());
ObIndexTreeRootBlockDesc &root_desc = res.root_desc_;
ASSERT_TRUE(root_desc.is_valid());
@ -1356,8 +1356,8 @@ TEST_F(TestIndexTree, test_meta_builder_mem_and_disk)
ASSERT_EQ(10, sst_builder->roots_[1]->meta_block_info_.get_row_count());
ASSERT_EQ(OB_SUCCESS, sst_builder->close(res));
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(true, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(true, res.table_backup_flag_.has_local());
ObSSTableMergeRes tmp_res;
@ -1763,8 +1763,8 @@ TEST_F(TestIndexTree, test_reuse_macro_block)
for (int64_t i = 0; i < res.data_blocks_cnt_; ++i) {
ASSERT_EQ(res.data_block_ids_.at(i), reused_res.data_block_ids_.at(i));
}
ASSERT_EQ(false, res.table_flag_.has_backup());
ASSERT_EQ(true, res.table_flag_.has_local());
ASSERT_EQ(false, res.table_backup_flag_.has_backup());
ASSERT_EQ(true, res.table_backup_flag_.has_local());
sst_builder->~ObSSTableIndexBuilder();
}
@ -1902,8 +1902,8 @@ TEST_F(TestIndexTree, test_rebuilder)
OK(data_writer.close());
ObSSTableMergeRes res1;
OK(sstable_builder1.close(res1));
ASSERT_EQ(false, res1.table_flag_.has_backup());
ASSERT_EQ(true, res1.table_flag_.has_local());
ASSERT_EQ(false, res1.table_backup_flag_.has_backup());
ASSERT_EQ(true, res1.table_backup_flag_.has_local());
ObIndexBlockRebuilder rebuilder;
OK(rebuilder.init(sstable_builder2, nullptr, 0));
@ -1934,8 +1934,8 @@ TEST_F(TestIndexTree, test_rebuilder)
OK(rebuilder.close());
ObSSTableMergeRes res2;
OK(sstable_builder2.close(res2));
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
// compare merge res
ASSERT_EQ(res1.root_desc_.height_, res2.root_desc_.height_);
ASSERT_EQ(res1.root_desc_.height_, 2);
@ -2128,8 +2128,8 @@ TEST_F(TestIndexTree, test_absolute_offset)
ObSSTableMergeRes res2;
OK(sstable_builder.close(res2));
ASSERT_GT(res2.root_desc_.height_, 2);
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
ObMicroBlockReaderHelper reader_helper;
ObIMicroBlockReader *micro_reader;
@ -2227,8 +2227,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_all_mem)
OK(data_writer.close());
ObSSTableMergeRes res1;
OK(sstable_builder1.close(res1));
ASSERT_EQ(false, res1.table_flag_.has_backup());
ASSERT_EQ(true, res1.table_flag_.has_local());
ASSERT_EQ(false, res1.table_backup_flag_.has_backup());
ASSERT_EQ(true, res1.table_backup_flag_.has_local());
ObIndexBlockRebuilder rebuilder;
OK(mock_init_backup_rebuilder(rebuilder, sstable_builder2));
@ -2265,8 +2265,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_all_mem)
ASSERT_EQ(true, rebuilder.index_tree_root_ctx_->index_tree_info_.in_mem());
rebuilder.~ObIndexBlockRebuilder();
OK(sstable_builder2.close(res2));
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
ASSERT_EQ(true, res2.data_root_desc_.is_mem_type());
ASSERT_EQ(true, res2.root_desc_.is_mem_type());
// compare merge res
@ -2336,8 +2336,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_all_disk)
OK(data_writer.close());
ObSSTableMergeRes res1;
OK(sstable_builder1.close(res1));
ASSERT_EQ(false, res1.table_flag_.has_backup());
ASSERT_EQ(true, res1.table_flag_.has_local());
ASSERT_EQ(false, res1.table_backup_flag_.has_backup());
ASSERT_EQ(true, res1.table_backup_flag_.has_local());
ObIndexBlockRebuilder rebuilder;
OK(mock_init_backup_rebuilder(rebuilder, sstable_builder2));
@ -2374,8 +2374,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_all_disk)
ObSSTableMergeRes res2;
OK(sstable_builder2.close(res2));
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
// compare merge res
ASSERT_EQ(res1.root_desc_.height_, res2.root_desc_.height_);
// ASSERT_EQ(res1.root_desc_.height_, 2);
@ -2443,8 +2443,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_mem_and_disk)
OK(data_writer.close());
ObSSTableMergeRes res1;
OK(sstable_builder1.close(res1));
ASSERT_EQ(false, res1.table_flag_.has_backup());
ASSERT_EQ(true, res1.table_flag_.has_local());
ASSERT_EQ(false, res1.table_backup_flag_.has_backup());
ASSERT_EQ(true, res1.table_backup_flag_.has_local());
ObIndexBlockRebuilder rebuilder_mem;
OK(mock_init_backup_rebuilder(rebuilder_mem, sstable_builder2));
ObIndexBlockRebuilder rebuilder;
@ -2496,8 +2496,8 @@ TEST_F(TestIndexTree, test_rebuilder_backup_mem_and_disk)
rebuilder.~ObIndexBlockRebuilder();
ObSSTableMergeRes res2;
OK(sstable_builder2.close(res2));
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
}
TEST_F(TestIndexTree, test_cg_compaction_all_mem)
@ -2554,8 +2554,8 @@ TEST_F(TestIndexTree, test_cg_compaction_all_mem)
OK(sstable_builder2.close(res2));
ASSERT_EQ(false, res2.table_flag_.has_backup());
ASSERT_EQ(true, res2.table_flag_.has_local());
ASSERT_EQ(false, res2.table_backup_flag_.has_backup());
ASSERT_EQ(true, res2.table_backup_flag_.has_local());
ASSERT_EQ(true, res2.data_root_desc_.is_mem_type());
ASSERT_EQ(true, res2.root_desc_.is_mem_type());
// compare merge res

6
src/observer/virtual_table/ob_all_virtual_table_mgr.cpp
View File

@ -315,7 +315,7 @@ int ObAllVirtualTableMgr::process_curr_tenant(common::ObNewRow *&row)
break;
}
case TABLE_FLAG: {
ObTableFlag table_flag;
ObTableBackupFlag table_backup_flag;
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
SERVER_LOG(WARN, "table should not be null", K(ret), KP(table));
@ -324,10 +324,10 @@ int ObAllVirtualTableMgr::process_curr_tenant(common::ObNewRow *&row)
if (OB_FAIL(static_cast<blocksstable::ObSSTable *>(table)->get_meta(sst_meta_hdl))) {
SERVER_LOG(WARN, "fail to get sstable meta handle", K(ret));
} else {
table_flag = sst_meta_hdl.get_sstable_meta().get_table_flag();
table_backup_flag = sst_meta_hdl.get_sstable_meta().get_table_backup_flag();
}
}
cur_row_.cells_[i].set_int(table_flag.flag_);
cur_row_.cells_[i].set_int(table_backup_flag.flag_);
break;
}
default:

26
src/storage/blocksstable/index_block/ob_index_block_builder.cpp
View File

@ -170,11 +170,11 @@ ObSSTableMergeRes::ObSSTableMergeRes()
master_key_id_(0),
nested_offset_(0),
nested_size_(0),
table_flag_(),
table_backup_flag_(),
root_row_store_type_(ObRowStoreType::MAX_ROW_STORE)
{
MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
table_flag_.clear();
table_backup_flag_.clear();
if (share::is_reserve_mode()) {
ObMemAttr attr(MTL_ID(), "SSTMrgeResArr", ObCtxIds::MERGE_RESERVE_CTX_ID);
data_block_ids_.set_attr(attr);
@ -225,7 +225,7 @@ void ObSSTableMergeRes::reset()
master_key_id_ = 0;
nested_offset_ = 0;
nested_size_ = 0;
table_flag_.clear();
table_backup_flag_.clear();
root_row_store_type_ = ObRowStoreType::MAX_ROW_STORE;
}
@ -239,7 +239,7 @@ bool ObSSTableMergeRes::is_valid() const
&& data_column_cnt_ > 0
&& nested_offset_ >= 0
&& nested_size_ >= 0
&& table_flag_.is_valid()
&& table_backup_flag_.is_valid()
&& root_row_store_type_ < ObRowStoreType::MAX_ROW_STORE;
}
@ -259,7 +259,7 @@ int ObSSTableMergeRes::assign(const ObSSTableMergeRes &src)
row_count_ = src.row_count_;
max_merged_trans_version_ = src.max_merged_trans_version_;
contain_uncommitted_row_ = src.contain_uncommitted_row_;
table_flag_ = src.table_flag_;
table_backup_flag_ = src.table_backup_flag_;
occupy_size_ = src.occupy_size_;
original_size_ = src.original_size_;
data_checksum_ = src.data_checksum_;
@ -327,27 +327,27 @@ int ObSSTableMergeRes::fill_column_checksum_for_empty_major(
void ObSSTableMergeRes::set_table_flag_with_macro_id_array()
{
table_flag_.set_no_backup();
table_flag_.set_no_local();
table_backup_flag_.set_no_backup();
table_backup_flag_.set_no_local();
for (int64_t i = 0; i < other_block_ids_.count(); ++i) {
const MacroBlockId &block_id = other_block_ids_.at(i);
if (block_id.is_local_id()) {
table_flag_.set_has_local();
table_backup_flag_.set_has_local();
} else if (block_id.is_backup_id()) {
table_flag_.set_has_backup();
table_backup_flag_.set_has_backup();
}
if (table_flag_.has_backup() && table_flag_.has_local()) {
if (table_backup_flag_.has_backup() && table_backup_flag_.has_local()) {
break;
}
}
for (int64_t j = 0; j < data_block_ids_.count(); ++j) {
const MacroBlockId &block_id = data_block_ids_.at(j);
if (block_id.is_local_id()) {
table_flag_.set_has_local();
table_backup_flag_.set_has_local();
} else if (block_id.is_backup_id()) {
table_flag_.set_has_backup();
table_backup_flag_.set_has_backup();
}
if (table_flag_.has_backup() && table_flag_.has_local()) {
if (table_backup_flag_.has_backup() && table_backup_flag_.has_local()) {
break;
}
}

4
src/storage/blocksstable/index_block/ob_index_block_builder.h
View File

@ -266,7 +266,7 @@ public:
K_(data_column_cnt), K_(data_column_checksums),
K_(row_count), K_(max_merged_trans_version), K_(contain_uncommitted_row),
K_(occupy_size), K_(original_size), K_(data_checksum), K_(use_old_macro_block_count),
K_(compressor_type), K_(root_row_store_type), K_(nested_offset), K_(nested_size), K_(table_flag),
K_(compressor_type), K_(root_row_store_type), K_(nested_offset), K_(nested_size), K_(table_backup_flag),
K_(encrypt_id), K_(master_key_id), KPHEX_(encrypt_key, sizeof(encrypt_key_)));
public:
ObIndexTreeRootBlockDesc root_desc_;
@ -290,7 +290,7 @@ public:
int64_t master_key_id_;
int64_t nested_offset_;
int64_t nested_size_;
ObTableFlag table_flag_;
ObTableBackupFlag table_backup_flag_;
ObRowStoreType root_row_store_type_;
char encrypt_key_[share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH];
DISALLOW_COPY_AND_ASSIGN(ObSSTableMergeRes);

29
src/storage/blocksstable/ob_sstable_meta.cpp
View File

@ -64,8 +64,9 @@ ObSSTableBasicMeta::ObSSTableBasicMeta()
master_key_id_(0),
sstable_logic_seq_(0),
latest_row_store_type_(ObRowStoreType::MAX_ROW_STORE),
table_flag_(),
root_macro_seq_(0)
root_macro_seq_(0),
table_backup_flag_(),
table_shared_flag_()
{
MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
}
@ -118,7 +119,8 @@ bool ObSSTableBasicMeta::check_basic_meta_equality(const ObSSTableBasicMeta &oth
&& master_key_id_ == other.master_key_id_
&& 0 == MEMCMP(encrypt_key_, other.encrypt_key_, sizeof(encrypt_key_))
&& latest_row_store_type_ == other.latest_row_store_type_
&& table_flag_ == other.table_flag_;
&& table_backup_flag_ == other.table_backup_flag_
&& table_shared_flag_ == other.table_shared_flag_;
}
bool ObSSTableBasicMeta::is_valid() const
@ -146,7 +148,8 @@ bool ObSSTableBasicMeta::is_valid() const
&& sstable_logic_seq_ >= 0
&& root_row_store_type_ < ObRowStoreType::MAX_ROW_STORE
&& is_latest_row_store_type_valid())
&& table_flag_.is_valid();
&& table_backup_flag_.is_valid()
&& table_shared_flag_.is_valid();
return ret;
}
@ -186,7 +189,8 @@ void ObSSTableBasicMeta::reset()
sstable_logic_seq_ = 0;
MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
latest_row_store_type_ = ObRowStoreType::MAX_ROW_STORE;
table_flag_.reset();
table_backup_flag_.reset();
table_shared_flag_.reset();
}
DEFINE_SERIALIZE(ObSSTableBasicMeta)
@ -243,7 +247,8 @@ DEFINE_SERIALIZE(ObSSTableBasicMeta)
master_key_id_,
sstable_logic_seq_,
latest_row_store_type_,
table_flag_);
table_backup_flag_,
table_shared_flag_);
if (OB_FAIL(ret)) {
} else if (OB_UNLIKELY(length_ != pos - start_pos)) {
ret = OB_ERR_UNEXPECTED;
@ -324,7 +329,8 @@ int ObSSTableBasicMeta::decode_for_compat(const char *buf, const int64_t data_le
master_key_id_,
sstable_logic_seq_,
latest_row_store_type_,
table_flag_);
table_backup_flag_,
table_shared_flag_);
return ret;
}
@ -366,7 +372,8 @@ DEFINE_GET_SERIALIZE_SIZE(ObSSTableBasicMeta)
master_key_id_,
sstable_logic_seq_,
latest_row_store_type_,
table_flag_);
table_backup_flag_,
table_shared_flag_);
return len;
}
@ -643,7 +650,8 @@ int ObSSTableMeta::init_base_meta(
basic_meta_.encrypt_id_ = param.encrypt_id_;
basic_meta_.master_key_id_ = param.master_key_id_;
MEMCPY(basic_meta_.encrypt_key_, param.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
basic_meta_.table_flag_ = param.table_flag_;
basic_meta_.table_backup_flag_ = param.table_backup_flag_;
basic_meta_.table_shared_flag_ = param.table_shared_flag_;
basic_meta_.length_ = basic_meta_.get_serialize_size();
if (OB_FAIL(prepare_column_checksum(param.column_checksums_, allocator))) {
LOG_WARN("fail to prepare column checksum", K(ret), K(param));
@ -1389,6 +1397,9 @@ int ObSSTableMetaChecker::check_sstable_basic_meta(
} else if (new_sstable_basic_meta.column_cnt_ != old_sstable_basic_meta.column_cnt_) {
ret = OB_INVALID_DATA;
LOG_WARN("column_cnt_ not match", K(ret), K(old_sstable_basic_meta), K(new_sstable_basic_meta));
} else if (new_sstable_basic_meta.table_shared_flag_ != old_sstable_basic_meta.table_shared_flag_) {
ret = OB_INVALID_DATA;
LOG_WARN("table_shared_flag_ not match", K(ret), K(old_sstable_basic_meta), K(new_sstable_basic_meta));
}
return ret;
}

8
src/storage/blocksstable/ob_sstable_meta.h
View File

@ -148,7 +148,7 @@ public:
K(ddl_scn_), K(filled_tx_scn_),
K(contain_uncommitted_row_), K(status_), K_(root_row_store_type), K_(compressor_type),
K_(encrypt_id), K_(master_key_id), K_(sstable_logic_seq), KPHEX_(encrypt_key, sizeof(encrypt_key_)),
K_(latest_row_store_type), K_(table_flag));
K_(latest_row_store_type), K_(table_backup_flag), K_(table_shared_flag));
public:
int32_t version_;
@ -187,8 +187,10 @@ public:
int16_t sstable_logic_seq_;
common::ObRowStoreType latest_row_store_type_;
char encrypt_key_[share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH];
storage::ObTableFlag table_flag_;
int64_t root_macro_seq_; // placeholder, will be used after palf branch merged
storage::ObTableBackupFlag table_backup_flag_; //cannot add backup flag to ObSSTableMetaChecker
//quick restore with rebuild replace major will has same key sstable
storage::ObTableSharedFlag table_shared_flag_;
//Add new variable need consider ObSSTableMetaChecker
};
@ -280,7 +282,7 @@ public:
OB_INLINE int64_t get_progressive_merge_step() const { return basic_meta_.progressive_merge_step_; }
OB_INLINE const ObRootBlockInfo &get_root_info() const { return data_root_info_; }
OB_INLINE const ObSSTableMacroInfo &get_macro_info() const { return macro_info_; }
OB_INLINE const ObTableFlag &get_table_flag() const { return basic_meta_.table_flag_; }
OB_INLINE const ObTableBackupFlag &get_table_backup_flag() const { return basic_meta_.table_backup_flag_; }
int load_root_block_data(common::ObArenaAllocator &allocator); //TODO:@jinzhu remove me after using kv cache.
inline int transform_root_block_extra_buf(common::ObArenaAllocator &allocator)
{

55
src/storage/blocksstable/ob_table_flag.cpp
View File

@ -18,55 +18,82 @@ namespace oceanbase
namespace storage
{
ObTableFlag::ObTableFlag()
ObTableBackupFlag::ObTableBackupFlag()
: has_backup_flag_(ObTableHasBackupFlag::NO_BACKUP),
has_local_flag_(ObTableHasLocalFlag::HAS_LOCAL),
is_shared_flag_(ObTableIsSharedFlag::IS_NOT_SHARED),
reserved_(0)
{
}
ObTableFlag::ObTableFlag(int64_t flag)
ObTableBackupFlag::ObTableBackupFlag(int64_t flag)
: flag_(flag)
{
}
ObTableFlag::~ObTableFlag()
ObTableBackupFlag::~ObTableBackupFlag()
{
}
void ObTableFlag::reset()
void ObTableBackupFlag::reset()
{
has_backup_flag_ = ObTableHasBackupFlag::NO_BACKUP;
has_local_flag_ = ObTableHasLocalFlag::HAS_LOCAL;
is_shared_flag_ = ObTableIsSharedFlag::IS_NOT_SHARED;
reserved_ = 0;
}
bool ObTableFlag::is_valid() const
bool ObTableBackupFlag::is_valid() const
{
return has_backup_flag_ >= ObTableHasBackupFlag::NO_BACKUP && has_backup_flag_ < ObTableHasBackupFlag::MAX
&& has_local_flag_ >= ObTableHasLocalFlag::HAS_LOCAL && has_local_flag_ < ObTableHasLocalFlag::MAX
&& is_shared_flag_ >= ObTableIsSharedFlag::IS_NOT_SHARED && is_shared_flag_ < ObTableIsSharedFlag::MAX;
&& has_local_flag_ >= ObTableHasLocalFlag::HAS_LOCAL && has_local_flag_ < ObTableHasLocalFlag::MAX;
}
void ObTableFlag::set_default()
void ObTableBackupFlag::set_default()
{
has_backup_flag_ = ObTableHasBackupFlag::NO_BACKUP;
has_local_flag_ = ObTableHasLocalFlag::HAS_LOCAL;
is_shared_flag_ = ObTableIsSharedFlag::IS_NOT_SHARED;
reserved_ = 0;
}
void ObTableFlag::clear()
void ObTableBackupFlag::clear()
{
has_backup_flag_ = ObTableHasBackupFlag::NO_BACKUP;
has_local_flag_ = ObTableHasLocalFlag::NO_LOCAL;
is_shared_flag_ = ObTableIsSharedFlag::IS_NOT_SHARED;
reserved_ = 0;
}
OB_SERIALIZE_MEMBER(ObTableFlag, flag_);
OB_SERIALIZE_MEMBER(ObTableBackupFlag, flag_);
ObTableSharedFlag::ObTableSharedFlag()
: shared_flag_(PRIVATE),
reserved_(0)
{
}
ObTableSharedFlag::~ObTableSharedFlag()
{
}
void ObTableSharedFlag::reset()
{
shared_flag_ = PRIVATE;
reserved_ = 0;
}
bool ObTableSharedFlag::is_valid() const
{
return shared_flag_ >= PRIVATE && shared_flag_ < MAX;
}
void ObTableSharedFlag::set_default()
{
shared_flag_ = PRIVATE;
reserved_ = 0;
}
OB_SERIALIZE_MEMBER(ObTableSharedFlag, flag_);
}
}

97
src/storage/blocksstable/ob_table_flag.h
View File

@ -45,32 +45,21 @@ public:
};
};
class ObTableIsSharedFlag final
{
public:
enum FLAG
{
IS_NOT_SHARED = 0,
IS_SHARED = 1,
MAX
};
};
struct ObTableFlag final
struct ObTableBackupFlag final
{
OB_UNIS_VERSION(1);
public:
ObTableFlag();
ObTableBackupFlag();
// TODO: yangyi.yyy to Refactor
ObTableFlag(int64_t flag);
~ObTableFlag();
ObTableBackupFlag(int64_t flag);
~ObTableBackupFlag();
void reset();
bool is_valid() const;
OB_INLINE bool operator==(const ObTableFlag &other) const;
OB_INLINE bool operator!=(const ObTableFlag &other) const;
OB_INLINE bool operator==(const ObTableBackupFlag &other) const;
OB_INLINE bool operator!=(const ObTableBackupFlag &other) const;
void set_default();
void clear();
TO_STRING_KV(K_(has_backup_flag), K_(has_local_flag), K_(is_shared_flag));
TO_STRING_KV(K_(has_backup_flag), K_(has_local_flag));
public:
bool has_backup() const { return ObTableHasBackupFlag::HAS_BACKUP == has_backup_flag_; }
@ -84,34 +73,86 @@ public:
private:
static const uint64_t SF_BIT_HAS_BACKUP = 1;
static const uint64_t SF_BIT_HAS_LOCAL = 1;
static const uint64_t SF_BIT_IS_SHARED = 1;
static const uint64_t SF_BIT_RESERVED = 61;
static const uint64_t SF_BIT_RESERVED = 30;
public:
union {
int64_t flag_;
int32_t flag_;
struct {
ObTableHasBackupFlag::FLAG has_backup_flag_ : SF_BIT_HAS_BACKUP;
ObTableHasLocalFlag::FLAG has_local_flag_ : SF_BIT_HAS_LOCAL;
ObTableIsSharedFlag::FLAG is_shared_flag_ : SF_BIT_IS_SHARED;
int64_t reserved_: SF_BIT_RESERVED;
};
};
};
bool ObTableFlag::operator==(const ObTableFlag &other) const
bool ObTableBackupFlag::operator==(const ObTableBackupFlag &other) const
{
return has_backup_flag_ == other.has_backup_flag_
&& has_local_flag_ == other.has_local_flag_
&& is_shared_flag_ == other.is_shared_flag_;
return flag_ == other.flag_;
}
bool ObTableFlag::operator!=(const ObTableFlag &other) const
bool ObTableBackupFlag::operator!=(const ObTableBackupFlag &other) const
{
return !(this->operator==(other));
}
struct ObTableSharedFlag final
{
OB_UNIS_VERSION(1);
public:
enum FLAG : uint8_t
{
PRIVATE = 0, //share nothing
SHARED_SSTABLE = 1, //sstable is public data, including meta tree and data
SHARED_MACRO_BLOCKS = 2, //only macro block is public data, meta tree is private
MAX
};
public:
ObTableSharedFlag();
~ObTableSharedFlag();
void reset();
bool is_valid() const;
OB_INLINE bool operator==(const ObTableSharedFlag &other) const;
OB_INLINE bool operator!=(const ObTableSharedFlag &other) const;
void set_default();
void clear();
void set_private() { shared_flag_ = PRIVATE; }
void set_shared_sstable() { shared_flag_ = SHARED_SSTABLE; }
void set_share_macro_blocks() { shared_flag_ = SHARED_MACRO_BLOCKS; }
bool is_shared_macro_blocks() const {
return SHARED_SSTABLE == shared_flag_
|| SHARED_MACRO_BLOCKS == shared_flag_; }
bool is_shared_sstable() const { return SHARED_SSTABLE == shared_flag_; }
bool is_only_shared_macro_blocks() const {
return SHARED_SSTABLE != shared_flag_
&& SHARED_MACRO_BLOCKS == shared_flag_; }
TO_STRING_KV(K_(shared_flag), K_(reserved));
private:
static const uint64_t SF_BIT_IS_SHARED = 8;
static const uint64_t SF_BIT_RESERVED = 24;
union {
int32_t flag_;
struct {;
FLAG shared_flag_ : SF_BIT_IS_SHARED;
int32_t reserved_: SF_BIT_RESERVED;
};
};
};
bool ObTableSharedFlag::operator==(const ObTableSharedFlag &other) const
{
return flag_ == other.flag_;
}
bool ObTableSharedFlag::operator!=(const ObTableSharedFlag &other) const
{
return !(this->operator==(other));
}
}
}
#endif
#endif

16
src/storage/high_availability/ob_physical_copy_task.cpp
View File

@ -917,7 +917,7 @@ int ObSSTableCopyFinishTask::get_space_optimization_mode_(
mode = ObSSTableIndexBuilder::DISABLE;
} else if (sstable_param->is_small_sstable_) {
mode = ObSSTableIndexBuilder::ENABLE;
} else if (sstable_param->basic_meta_.table_flag_.has_backup()) {
} else if (sstable_param->basic_meta_.table_backup_flag_.has_backup()) {
mode = ObSSTableIndexBuilder::ENABLE;
} else {
mode = ObSSTableIndexBuilder::DISABLE;
@ -1140,14 +1140,14 @@ int ObSSTableCopyFinishTask::build_create_empty_sstable_param_(
} else if (ObTabletRestoreAction::is_restore_remote_sstable(copy_ctx_.restore_action_)) {
// Donot set has no local, otherwise, the sstable cannot be scheduled to restore. Then column sstable
// cannot be restored.
param.table_flag_.set_no_local();
param.table_flag_.set_has_backup();
param.table_backup_flag_.set_no_local();
param.table_backup_flag_.set_has_backup();
} else if (ObTabletRestoreAction::is_restore_replace_remote_sstable(copy_ctx_.restore_action_)) {
param.table_flag_.set_has_local();
param.table_flag_.set_no_backup();
param.table_backup_flag_.set_has_local();
param.table_backup_flag_.set_no_backup();
} else {
// for migration
param.table_flag_ = sstable_param_->basic_meta_.table_flag_;
param.table_backup_flag_ = sstable_param_->basic_meta_.table_backup_flag_;
}
return ret;
}
@ -1264,8 +1264,8 @@ int ObSSTableCopyFinishTask::build_create_pure_remote_sstable_param_(
} else if (OB_FAIL(param.init_for_remote(*sstable_param_))) {
LOG_WARN("failed to init for remote", K(ret));
} else {
param.table_flag_.set_has_backup();
param.table_flag_.set_no_local();
param.table_backup_flag_.set_has_backup();
param.table_backup_flag_.set_no_local();
}
return ret;
}

2
src/storage/high_availability/ob_storage_ha_reader.cpp
View File

@ -3147,7 +3147,7 @@ int ObCopyRemoteSSTableInfoObProducer::check_need_copy_sstable_(
need_copy_sstable = true;
} else if (OB_FAIL(sstable->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get sstable meta handle", K(ret), KPC(sstable));
} else if (sst_meta_hdl.get_sstable_meta().get_table_flag().has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_table_backup_flag().has_backup()) {
need_copy_sstable = true;
}

10
src/storage/high_availability/ob_tablet_group_restore.cpp
View File

@ -2717,7 +2717,7 @@ int ObTabletRestoreTask::check_remote_sstable_exist_in_table_store_(
need_copy = true;
} else if (OB_FAIL(sstable->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get sstable meta handle", K(ret), KPC(sstable));
} else if (sst_meta_hdl.get_sstable_meta().get_table_flag().has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_table_backup_flag().has_backup()) {
need_copy = true;
} else {
need_copy = false;
@ -2928,7 +2928,7 @@ int ObTabletFinishRestoreTask::verify_table_store_()
// do nothing
} else if (OB_FAIL(static_cast<ObSSTable *>(table)->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(table));
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("remote table should not exist", K(ret), KPC(table));
}
@ -2949,7 +2949,7 @@ int ObTabletFinishRestoreTask::verify_table_store_()
// do nothing
} else if (OB_FAIL(static_cast<ObSSTable *>(table)->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(table));
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("remote table should not exist", K(ret), KPC(table));
}
@ -2970,7 +2970,7 @@ int ObTabletFinishRestoreTask::verify_table_store_()
// do nothing
} else if (OB_FAIL(static_cast<ObSSTable *>(table)->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(table));
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("remote table should not exist", K(ret), KPC(table));
}
@ -2995,7 +2995,7 @@ int ObTabletFinishRestoreTask::verify_table_store_()
LOG_WARN("table is not sstable", K(ret), KPC(table));
} else if (OB_FAIL(static_cast<ObSSTable *>(table)->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(table));
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("remote table should not exist", K(ret), KPC(table));
}

3
src/storage/ls/ob_ls_tablet_service.cpp
View File

@ -2590,7 +2590,8 @@ int ObLSTabletService::build_create_sstable_param_for_migration(
MEMCPY(param.encrypt_key_, mig_param.basic_meta_.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
param.root_block_addr_.set_none_addr();
param.data_block_macro_meta_addr_.set_none_addr();;
param.table_flag_ = mig_param.basic_meta_.table_flag_;
param.table_backup_flag_ = mig_param.basic_meta_.table_backup_flag_;
param.table_shared_flag_ = mig_param.basic_meta_.table_shared_flag_;
if (OB_FAIL(param.column_checksums_.assign(mig_param.column_checksums_))) {
LOG_WARN("fail to assign column checksums", K(ret), K(mig_param));
}

2
src/storage/ob_i_table.cpp
View File

@ -890,7 +890,7 @@ int ObTablesHandleArray::get_all_remote_major_sstables(common::ObIArray<ObITable
// do nothing
} else if (OB_FAIL(sstable->get_meta(sst_meta_hdl))) {
STORAGE_LOG(WARN, "failed to get sstable meta handle", K(ret), K(i));
} else if (!sst_meta_hdl.get_sstable_meta().get_table_flag().has_backup()) {
} else if (!sst_meta_hdl.get_sstable_meta().get_table_backup_flag().has_backup()) {
// do nothing
} else if (OB_FAIL(tables.push_back(table))) {
STORAGE_LOG(WARN, "failed to add remote major sstable", K(ret), K(i));

2
src/storage/tablet/ob_tablet.cpp
View File

@ -7099,7 +7099,7 @@ int ObTablet::calc_sstable_occupy_size(int64_t &occupy_size, int64_t &pure_backu
} else {
const ObSSTableMeta &sstable_meta = meta_handle.get_sstable_meta();
occupy_size += sstable_meta.get_occupy_size();
if (!meta_handle.get_sstable_meta().get_basic_meta().table_flag_.has_local()) {
if (!meta_handle.get_sstable_meta().get_basic_meta().table_backup_flag_.has_local()) {
pure_backup_sstable_occupy_size += sstable_meta.get_occupy_size();
}
}

22
src/storage/tablet/ob_tablet_create_sstable_param.cpp
View File

@ -76,7 +76,8 @@ ObTabletCreateSSTableParam::ObTabletCreateSSTableParam()
nested_size_(0),
data_block_ids_(),
other_block_ids_(),
table_flag_(),
table_backup_flag_(),
table_shared_flag_(),
uncommitted_tx_id_(0)
{
MEMSET(encrypt_key_, 0, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
@ -91,9 +92,9 @@ bool ObTabletCreateSSTableParam::is_valid() const
} else if (OB_UNLIKELY(!table_mode_.is_valid())) {
ret = false;
LOG_WARN("invalid table mode", K(table_mode_));
} else if (OB_UNLIKELY(!table_flag_.is_valid())) {
} else if (OB_UNLIKELY(!table_backup_flag_.is_valid() || !table_shared_flag_.is_valid())) {
ret = false;
LOG_WARN("invalid table flag", K_(table_flag));
LOG_WARN("invalid table backup flag or invalid table shared flag", K_(table_backup_flag), K_(table_shared_flag));
} else if (!(schema_version_ >= 0
&& sstable_logic_seq_ >= 0
&& create_snapshot_version_ >= 0
@ -170,7 +171,7 @@ int ObTabletCreateSSTableParam::inner_init_with_merge_res(const blocksstable::Ob
STATIC_ASSERT(ARRAYSIZEOF(res.encrypt_key_) == share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH,
"ObSSTableMergeRes encrypt_key_ array size mismatch OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH");
MEMCPY(encrypt_key_, res.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
table_flag_ = res.table_flag_;
table_backup_flag_ = res.table_backup_flag_;
if (OB_FAIL(data_block_ids_.assign(res.data_block_ids_))) {
LOG_WARN("fail to fill data block ids", K(ret), K(res.data_block_ids_));
@ -205,7 +206,7 @@ int ObTabletCreateSSTableParam::init_for_small_sstable(const blocksstable::ObSST
max_merged_trans_version_ = res.max_merged_trans_version_;
nested_offset_ = block_info.nested_offset_;
nested_size_ = block_info.nested_size_;
table_flag_ = res.table_flag_;
table_shared_flag_.reset();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
} else if (table_key_.is_major_sstable()) {
@ -285,7 +286,7 @@ int ObTabletCreateSSTableParam::init_for_merge(const compaction::ObBasicTabletMe
nested_size_ = res.nested_size_;
nested_offset_ = res.nested_offset_;
ddl_scn_.set_min();
table_flag_ = res.table_flag_;
table_shared_flag_.reset();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to init with merge res", K(ret), K(res.data_block_ids_));
@ -390,7 +391,7 @@ int ObTabletCreateSSTableParam::init_for_ddl(blocksstable::ObSSTableIndexBuilder
max_merged_trans_version_ = ddl_param.snapshot_version_;
nested_size_ = res.nested_size_;
nested_offset_ = res.nested_offset_;
table_flag_ = res.table_flag_;
table_shared_flag_.reset();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to inner init with merge res", K(ret), K(res));
@ -450,7 +451,7 @@ int ObTabletCreateSSTableParam::init_for_ha(
max_merged_trans_version_ = res.max_merged_trans_version_;
rowkey_column_cnt_ = sstable_param.basic_meta_.rowkey_column_count_;
ddl_scn_ = sstable_param.basic_meta_.ddl_scn_;
table_flag_ = res.table_flag_;
table_shared_flag_ = sstable_param.basic_meta_.table_shared_flag_;
if (table_key_.is_co_sstable()) {
column_group_cnt_ = sstable_param.column_group_cnt_;
full_column_cnt_ = sstable_param.full_column_cnt_;
@ -500,7 +501,8 @@ int ObTabletCreateSSTableParam::init_for_ha(const blocksstable::ObMigrationSSTab
data_block_macro_meta_addr_.set_none_addr();
rowkey_column_cnt_ = sstable_param.basic_meta_.rowkey_column_count_;
MEMCPY(encrypt_key_, sstable_param.basic_meta_.encrypt_key_, share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH);
table_flag_ = sstable_param.basic_meta_.table_flag_;
table_backup_flag_ = sstable_param.basic_meta_.table_backup_flag_;
table_shared_flag_ = sstable_param.basic_meta_.table_shared_flag_;
if (table_key_.is_co_sstable()) {
column_group_cnt_ = sstable_param.column_group_cnt_;
is_co_table_without_cgs_ = table_key_.is_ddl_sstable() ? false : true;
@ -554,6 +556,7 @@ int ObTabletCreateSSTableParam::init_for_remote(const blocksstable::ObMigrationS
rowkey_column_cnt_ = sstable_param.basic_meta_.rowkey_column_count_;
ddl_scn_ = sstable_param.basic_meta_.ddl_scn_;
table_shared_flag_ = sstable_param.basic_meta_.table_shared_flag_;
if (table_key_.is_co_sstable()) {
column_group_cnt_ = sstable_param.column_group_cnt_;
full_column_cnt_ = sstable_param.full_column_cnt_;
@ -610,6 +613,7 @@ int ObTabletCreateSSTableParam::init_for_mds(
nested_size_ = res.nested_size_;
nested_offset_ = res.nested_offset_;
ddl_scn_.set_min();
table_shared_flag_.reset();
if (OB_FAIL(inner_init_with_merge_res(res))) {
LOG_WARN("fail to init with merge res", K(ret), K(res.data_block_ids_));

6
src/storage/tablet/ob_tablet_create_sstable_param.h
View File

@ -128,7 +128,8 @@ public:
K_(nested_offset),
K_(nested_size),
KPHEX_(encrypt_key, sizeof(encrypt_key_)),
K_(table_flag),
K_(table_backup_flag),
K_(table_shared_flag),
K_(uncommitted_tx_id));
private:
static const int64_t DEFAULT_MACRO_BLOCK_CNT = 64;
@ -179,7 +180,8 @@ public:
char encrypt_key_[share::OB_MAX_TABLESPACE_ENCRYPT_KEY_LENGTH];
common::ObSEArray<blocksstable::MacroBlockId, DEFAULT_MACRO_BLOCK_CNT> data_block_ids_;
common::ObSEArray<blocksstable::MacroBlockId, DEFAULT_MACRO_BLOCK_CNT> other_block_ids_;
storage::ObTableFlag table_flag_;
storage::ObTableBackupFlag table_backup_flag_; //ObTableBackupFlag will be updated by ObSSTableMergeRes
storage::ObTableSharedFlag table_shared_flag_; //ObTableSharedFlag will be updated by ObTabletCreateSSTableParam
int64_t uncommitted_tx_id_;
};

16
src/storage/tablet/ob_tablet_table_store.cpp
View File

@ -1464,7 +1464,7 @@ int ObTabletTableStore::inner_replace_remote_major_sstable_(
LOG_WARN("no major table exist", K(ret), K(old_store), KPC(new_table));
} else if (OB_FAIL(static_cast<ObSSTable *>(new_table)->get_meta(new_sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(new_table));
} else if (new_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (new_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("new table still has backup macro block", K(ret), KPC(new_table), K(new_sst_meta_hdl));
} else if (OB_FAIL(old_store.major_tables_.get_all_tables(old_tables_array))) {
@ -1478,7 +1478,7 @@ int ObTabletTableStore::inner_replace_remote_major_sstable_(
LOG_WARN("get unexpected null table", K(ret), K(old_store));
} else if (OB_FAIL(static_cast<ObSSTable *>(old_table)->get_meta(old_sst_meta_hdl))) {
LOG_WARN("failed to get old sstable meta handle", K(ret), KPC(old_table));
} else if (old_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_no_backup()) {
} else if (old_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_no_backup()) {
if (OB_FAIL(new_tables_array.push_back(old_table))) {
LOG_WARN("failed to push back", K(ret));
}
@ -2173,14 +2173,14 @@ int ObTabletTableStore::check_new_sstable_can_be_accepted_(
ObSSTableMetaHandle old_sst_meta_hdl;
if (OB_FAIL(static_cast<ObSSTable *>(new_table)->get_meta(new_sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(new_table));
} else if (new_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (new_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
// compaction during restore, and backup macro block is reused by the new table.
bool has_remote_sstable = false;
for (int64_t i = 0; OB_SUCC(ret) && i < old_tables.count(); ++i) {
old_table = old_tables.at(i);
if (OB_FAIL(static_cast<ObSSTable *>(old_table)->get_meta(old_sst_meta_hdl))) {
LOG_WARN("failed to get old sstable meta handle", K(ret), KPC(old_table));
} else if (old_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (old_sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
has_remote_sstable = true;
break;
}
@ -2206,7 +2206,7 @@ int ObTabletTableStore::check_new_major_sstable_can_be_accepted_(
ObSSTableMetaHandle sst_meta_hdl;
if (OB_FAIL(static_cast<ObSSTable *>(major_table)->get_meta(sst_meta_hdl))) {
LOG_WARN("failed to get new sstable meta handle", K(ret), KPC(major_table));
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_flag_.has_no_backup()) {
} else if (sst_meta_hdl.get_sstable_meta().get_basic_meta().table_backup_flag_.has_no_backup()) {
// do nothing
} else if (OB_FAIL(old_store.ddl_sstables_.get_all_tables(ddl_sstables))) {
LOG_WARN("get ddl dump sstables failed", K(ret), K(old_store));
@ -2550,7 +2550,7 @@ int ObTabletTableStore::replace_ha_remote_ddl_tables_(
LOG_WARN("table type is unexpected", K(ret), KPC(major_table));
} else if (OB_FAIL(static_cast<ObSSTable *>(major_table)->get_meta(major_meta_handle))) {
LOG_WARN("get major table meta fail", K(ret), KPC(major_table));
} else if (major_meta_handle.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (major_meta_handle.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
// This remote major is generated with ddl sstables by ddl commit. In this case, replace cannot
// continue, should schedule replace remote major action again.
ret = OB_NO_NEED_MERGE;
@ -2921,7 +2921,7 @@ int ObTabletTableStore::replace_ha_remote_sstables_(
LOG_WARN("new table is not sstable", K(ret), KPC(new_table));
} else if (OB_FAIL(static_cast<ObSSTable *>(new_table)->get_meta(new_meta_handle))) {
LOG_WARN("get table meta handle fail", K(ret), KPC(new_table));
} else if (new_meta_handle.get_sstable_meta().get_basic_meta().table_flag_.has_backup()) {
} else if (new_meta_handle.get_sstable_meta().get_basic_meta().table_backup_flag_.has_backup()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("new table still has backup macro block", K(ret), KPC(new_table), K(new_meta_handle));
} else {
@ -2942,7 +2942,7 @@ int ObTabletTableStore::replace_ha_remote_sstables_(
LOG_WARN("old table is not sstable", K(ret), KPC(old_table));
} else if (OB_FAIL(static_cast<ObSSTable *>(old_table)->get_meta(old_meta_handle))) {
LOG_WARN("get table meta handle fail", K(ret), KPC(old_table));
} else if (old_meta_handle.get_sstable_meta().get_basic_meta().table_flag_.has_no_backup()) {
} else if (old_meta_handle.get_sstable_meta().get_basic_meta().table_backup_flag_.has_no_backup()) {
// this table does not has backup macro block, no need to be replaced.
if (check_continue && OB_NOT_NULL(last_table) && old_table->get_start_scn() != last_table->get_end_scn()) {
ret = OB_ERR_UNEXPECTED;