From c6abadd8cf1d6b287b251a08ccfdc615a96cc506 Mon Sep 17 00:00:00 2001 From: godyangfight Date: Wed, 21 Aug 2024 07:48:24 +0000 Subject: [PATCH] ObTableFlag split to ObTableBackFlag and ObTableSharedFlag --- .../blocksstable/test_index_dumper.cpp | 4 +- .../storage/blocksstable/test_index_tree.cpp | 76 +++++++-------- .../ob_all_virtual_table_mgr.cpp | 6 +- .../index_block/ob_index_block_builder.cpp | 26 ++--- .../index_block/ob_index_block_builder.h | 4 +- src/storage/blocksstable/ob_sstable_meta.cpp | 29 ++++-- src/storage/blocksstable/ob_sstable_meta.h | 8 +- src/storage/blocksstable/ob_table_flag.cpp | 55 ++++++++--- src/storage/blocksstable/ob_table_flag.h | 97 +++++++++++++------ .../ob_physical_copy_task.cpp | 16 +-- .../ob_storage_ha_reader.cpp | 2 +- .../ob_tablet_group_restore.cpp | 10 +- src/storage/ls/ob_ls_tablet_service.cpp | 3 +- src/storage/ob_i_table.cpp | 2 +- src/storage/tablet/ob_tablet.cpp | 2 +- .../tablet/ob_tablet_create_sstable_param.cpp | 22 +++-- .../tablet/ob_tablet_create_sstable_param.h | 6 +- src/storage/tablet/ob_tablet_table_store.cpp | 16 +-- 18 files changed, 236 insertions(+), 148 deletions(-) diff --git a/mittest/mtlenv/storage/blocksstable/test_index_dumper.cpp b/mittest/mtlenv/storage/blocksstable/test_index_dumper.cpp index 0c7138672..cdba2cba4 100644 --- a/mittest/mtlenv/storage/blocksstable/test_index_dumper.cpp +++ b/mittest/mtlenv/storage/blocksstable/test_index_dumper.cpp @@ -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_); diff --git a/mittest/mtlenv/storage/blocksstable/test_index_tree.cpp b/mittest/mtlenv/storage/blocksstable/test_index_tree.cpp index d4d3ef785..2f7e5632e 100644 --- a/mittest/mtlenv/storage/blocksstable/test_index_tree.cpp +++ b/mittest/mtlenv/storage/blocksstable/test_index_tree.cpp @@ -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 diff --git a/src/observer/virtual_table/ob_all_virtual_table_mgr.cpp b/src/observer/virtual_table/ob_all_virtual_table_mgr.cpp index 570315e34..95f6cce5a 100644 --- a/src/observer/virtual_table/ob_all_virtual_table_mgr.cpp +++ b/src/observer/virtual_table/ob_all_virtual_table_mgr.cpp @@ -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(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: diff --git a/src/storage/blocksstable/index_block/ob_index_block_builder.cpp b/src/storage/blocksstable/index_block/ob_index_block_builder.cpp index cbd599af3..351ec733a 100755 --- a/src/storage/blocksstable/index_block/ob_index_block_builder.cpp +++ b/src/storage/blocksstable/index_block/ob_index_block_builder.cpp @@ -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; } } diff --git a/src/storage/blocksstable/index_block/ob_index_block_builder.h b/src/storage/blocksstable/index_block/ob_index_block_builder.h index 61e919678..d53710808 100755 --- a/src/storage/blocksstable/index_block/ob_index_block_builder.h +++ b/src/storage/blocksstable/index_block/ob_index_block_builder.h @@ -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); diff --git a/src/storage/blocksstable/ob_sstable_meta.cpp b/src/storage/blocksstable/ob_sstable_meta.cpp index 90fac2193..565aae928 100644 --- a/src/storage/blocksstable/ob_sstable_meta.cpp +++ b/src/storage/blocksstable/ob_sstable_meta.cpp @@ -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; } diff --git a/src/storage/blocksstable/ob_sstable_meta.h b/src/storage/blocksstable/ob_sstable_meta.h index 7f02da5c7..1562a66ae 100644 --- a/src/storage/blocksstable/ob_sstable_meta.h +++ b/src/storage/blocksstable/ob_sstable_meta.h @@ -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) { diff --git a/src/storage/blocksstable/ob_table_flag.cpp b/src/storage/blocksstable/ob_table_flag.cpp index 8bc567de2..a50496612 100644 --- a/src/storage/blocksstable/ob_table_flag.cpp +++ b/src/storage/blocksstable/ob_table_flag.cpp @@ -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_); + } } diff --git a/src/storage/blocksstable/ob_table_flag.h b/src/storage/blocksstable/ob_table_flag.h index b434db332..fb4a59ad2 100644 --- a/src/storage/blocksstable/ob_table_flag.h +++ b/src/storage/blocksstable/ob_table_flag.h @@ -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 \ No newline at end of file +#endif diff --git a/src/storage/high_availability/ob_physical_copy_task.cpp b/src/storage/high_availability/ob_physical_copy_task.cpp index aaf439bd9..366bf8d1e 100644 --- a/src/storage/high_availability/ob_physical_copy_task.cpp +++ b/src/storage/high_availability/ob_physical_copy_task.cpp @@ -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; } diff --git a/src/storage/high_availability/ob_storage_ha_reader.cpp b/src/storage/high_availability/ob_storage_ha_reader.cpp index d0c7829b6..f8e319f94 100644 --- a/src/storage/high_availability/ob_storage_ha_reader.cpp +++ b/src/storage/high_availability/ob_storage_ha_reader.cpp @@ -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; } diff --git a/src/storage/high_availability/ob_tablet_group_restore.cpp b/src/storage/high_availability/ob_tablet_group_restore.cpp index ed4fd80fe..fd5c199f2 100644 --- a/src/storage/high_availability/ob_tablet_group_restore.cpp +++ b/src/storage/high_availability/ob_tablet_group_restore.cpp @@ -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(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(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(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(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)); } diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp index a5b0e1576..5b2b0e609 100644 --- a/src/storage/ls/ob_ls_tablet_service.cpp +++ b/src/storage/ls/ob_ls_tablet_service.cpp @@ -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)); } diff --git a/src/storage/ob_i_table.cpp b/src/storage/ob_i_table.cpp index 9abdaf542..6365cc466 100644 --- a/src/storage/ob_i_table.cpp +++ b/src/storage/ob_i_table.cpp @@ -890,7 +890,7 @@ int ObTablesHandleArray::get_all_remote_major_sstables(common::ObIArrayget_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)); diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp index 165e68034..69fbbfbe4 100644 --- a/src/storage/tablet/ob_tablet.cpp +++ b/src/storage/tablet/ob_tablet.cpp @@ -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(); } } diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.cpp b/src/storage/tablet/ob_tablet_create_sstable_param.cpp index 75e868b60..9e85fe8b5 100644 --- a/src/storage/tablet/ob_tablet_create_sstable_param.cpp +++ b/src/storage/tablet/ob_tablet_create_sstable_param.cpp @@ -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_)); diff --git a/src/storage/tablet/ob_tablet_create_sstable_param.h b/src/storage/tablet/ob_tablet_create_sstable_param.h index 7c2755c83..17d1b6fa8 100644 --- a/src/storage/tablet/ob_tablet_create_sstable_param.h +++ b/src/storage/tablet/ob_tablet_create_sstable_param.h @@ -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 data_block_ids_; common::ObSEArray 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_; }; diff --git a/src/storage/tablet/ob_tablet_table_store.cpp b/src/storage/tablet/ob_tablet_table_store.cpp index c401329a0..b3dabeec3 100644 --- a/src/storage/tablet/ob_tablet_table_store.cpp +++ b/src/storage/tablet/ob_tablet_table_store.cpp @@ -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(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(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(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(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(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(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(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(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;