diff --git a/mittest/mtlenv/storage/blocksstable/test_cg_group_by_scanner.cpp b/mittest/mtlenv/storage/blocksstable/test_cg_group_by_scanner.cpp index 8afe54d8a..b5ac04ea9 100644 --- a/mittest/mtlenv/storage/blocksstable/test_cg_group_by_scanner.cpp +++ b/mittest/mtlenv/storage/blocksstable/test_cg_group_by_scanner.cpp @@ -387,8 +387,8 @@ TEST_F(TestCGGroupByScanner, test_init) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); ASSERT_EQ(1, group_by_scanner.group_by_agg_idxs_.count()); @@ -409,8 +409,8 @@ TEST_F(TestCGGroupByScanner, test_decide_group_size) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); int64_t start = 0; @@ -434,8 +434,8 @@ TEST_F(TestCGGroupByScanner, test_decide_can_group_by) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -465,8 +465,8 @@ TEST_F(TestCGGroupByScanner, test_read_distinct) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -506,8 +506,8 @@ TEST_F(TestCGGroupByScanner, test_read_reference) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -556,8 +556,8 @@ TEST_F(TestCGGroupByScanner, test_calc_aggregate_group_by) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -635,8 +635,8 @@ TEST_F(TestCGGroupByScanner, test_calc_aggregate_group_by_with_bitmap) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); diff --git a/mittest/mtlenv/storage/blocksstable/test_cg_scanner.cpp b/mittest/mtlenv/storage/blocksstable/test_cg_scanner.cpp index 4c12502ff..91123ce85 100644 --- a/mittest/mtlenv/storage/blocksstable/test_cg_scanner.cpp +++ b/mittest/mtlenv/storage/blocksstable/test_cg_scanner.cpp @@ -244,8 +244,8 @@ void TestCGScanner::test_random(const bool is_reverse) buf = allocator_.alloc(sizeof(ObCGRowScanner)); ASSERT_NE(nullptr, buf); ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); int retry_cnt = 15; @@ -327,8 +327,8 @@ void TestCGScanner::test_border(const bool is_reverse) buf = allocator_.alloc(sizeof(ObCGRowScanner)); ASSERT_NE(nullptr, buf); ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); int64_t start = 0; @@ -417,8 +417,8 @@ TEST_F(TestCGScanner, test_large_micro_selected) buf = allocator_.alloc(sizeof(ObCGRowScanner)); ASSERT_NE(nullptr, buf); ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); int64_t start = 0; @@ -578,8 +578,8 @@ TEST_F(TestCGScanner, test_filter) buf = allocator_.alloc(sizeof(ObCGRowScanner)); ASSERT_NE(nullptr, buf); ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); sql::PushdownFilterInfo pd_filter; diff --git a/mittest/mtlenv/storage/blocksstable/test_cs_cg_group_by_scanner.cpp b/mittest/mtlenv/storage/blocksstable/test_cs_cg_group_by_scanner.cpp index 2c276a136..327ccdab7 100644 --- a/mittest/mtlenv/storage/blocksstable/test_cs_cg_group_by_scanner.cpp +++ b/mittest/mtlenv/storage/blocksstable/test_cs_cg_group_by_scanner.cpp @@ -388,8 +388,8 @@ TEST_F(TestCSCGGroupByScanner, test_init) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); ASSERT_EQ(1, group_by_scanner.group_by_agg_idxs_.count()); @@ -410,8 +410,8 @@ TEST_F(TestCSCGGroupByScanner, test_decide_group_size) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); int64_t start = 0; @@ -435,8 +435,8 @@ TEST_F(TestCSCGGroupByScanner, test_decide_can_group_by) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -466,8 +466,8 @@ TEST_F(TestCSCGGroupByScanner, test_read_distinct) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -507,8 +507,8 @@ TEST_F(TestCSCGGroupByScanner, test_read_reference) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -553,8 +553,8 @@ TEST_F(TestCSCGGroupByScanner, test_calc_aggregate_group_by) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); @@ -637,8 +637,8 @@ TEST_F(TestCSCGGroupByScanner, test_calc_aggregate_group_by_with_bitmap) context_.block_row_store_ = &vector_store; ObCGGroupByScanner group_by_scanner; - ObCGTableWrapper wrapper; - wrapper.cg_sstable_ = &sstable_; + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; ASSERT_EQ(OB_SUCCESS, group_by_scanner.init(cg_access_param_.iter_param_, context_, wrapper)); ASSERT_EQ(OB_SUCCESS, group_by_scanner.init_group_by_info()); diff --git a/src/storage/backup/ob_backup_reader.cpp b/src/storage/backup/ob_backup_reader.cpp index a7a3107da..24ed4408a 100644 --- a/src/storage/backup/ob_backup_reader.cpp +++ b/src/storage/backup/ob_backup_reader.cpp @@ -621,26 +621,20 @@ int ObSSTableMetaBackupReader::get_meta_data(blocksstable::ObBufferReader &buffe } else { for (int64_t i = 0; OB_SUCC(ret) && i < sstable_array_.count(); ++i) { int64_t pos = 0; - ObITable *table_ptr = sstable_array_.at(i); - if (OB_ISNULL(table_ptr)) { + ObSSTable *sstable_ptr = sstable_array_.at(i).get_sstable(); + if (OB_ISNULL(sstable_ptr)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("get invalid table ptr", K(ret), K(i)); } else { // TODO(COLUMN_STORE) Attention !!! column store table key is COSSTable now! maybe should adapt. - const ObITable::TableKey &table_key = table_ptr->get_key(); + const ObITable::TableKey &table_key = sstable_ptr->get_key(); ObTablet *tablet = tablet_handle_->get_obj(); - ObSSTable *sstable_ptr = NULL; ObBackupSSTableMeta backup_sstable_meta; backup_sstable_meta.tablet_id_ = tablet_id_; - if ((backup_data_type_.is_major_backup() && !table_ptr->is_major_sstable()) - || (backup_data_type_.is_minor_backup() && !table_ptr->is_minor_sstable() && !table_ptr->is_ddl_dump_sstable())) { + if ((backup_data_type_.is_major_backup() && !sstable_ptr->is_major_sstable()) + || (backup_data_type_.is_minor_backup() && !sstable_ptr->is_minor_sstable() && !sstable_ptr->is_ddl_dump_sstable())) { ret = OB_ERR_SYS; - LOG_WARN("get incorrect table type", K(ret), K(i), K_(backup_data_type), KP(table_ptr)); - } else { - // TODO(COLUMN_STORE) Attention !!! column store table key is COSSTable now! maybe should adapt. - sstable_ptr = static_cast(table_ptr); - } - if (OB_FAIL(ret)) { + LOG_WARN("get incorrect table type", K(ret), K(i), K_(backup_data_type), KP(sstable_ptr)); } else if (OB_FAIL(tablet->build_migration_sstable_param(table_key, backup_sstable_meta.sstable_meta_))) { LOG_WARN("failed to build migration sstable param", K(ret), K(table_key)); } else if (OB_FAIL(get_macro_block_id_list_(*sstable_ptr, backup_sstable_meta))) { diff --git a/src/storage/backup/ob_backup_reader.h b/src/storage/backup/ob_backup_reader.h index 872fae881..50722ec18 100644 --- a/src/storage/backup/ob_backup_reader.h +++ b/src/storage/backup/ob_backup_reader.h @@ -269,7 +269,7 @@ private: int get_macro_block_id_list_(const blocksstable::ObSSTable &sstable, ObBackupSSTableMeta &sstable_meta); private: - common::ObArray sstable_array_; + common::ObArray sstable_array_; blocksstable::ObSelfBufferWriter buffer_writer_; ObTabletMemberWrapper table_store_wrapper_; DISALLOW_COPY_AND_ASSIGN(ObSSTableMetaBackupReader); diff --git a/src/storage/backup/ob_backup_task.cpp b/src/storage/backup/ob_backup_task.cpp index 0c9a94234..1c0b398da 100644 --- a/src/storage/backup/ob_backup_task.cpp +++ b/src/storage/backup/ob_backup_task.cpp @@ -3432,7 +3432,7 @@ int ObLSBackupDataTask::may_fill_reused_backup_items_( ObTabletMemberWrapper table_store_wrapper; ObBackupDataType backup_data_type; backup_data_type.set_major_data_backup(); - ObArray sstable_array; + ObArray sstable_array; if (OB_ISNULL(ls_backup_ctx_) || OB_ISNULL(tablet_stat)) { ret = OB_ERR_UNEXPECTED; @@ -3454,12 +3454,12 @@ int ObLSBackupDataTask::may_fill_reused_backup_items_( ret = OB_ERR_UNEXPECTED; LOG_WARN("sstable array count not 1", K(ret), K(sstable_array)); } else if (1 == sstable_array.count()) { - if (OB_FAIL(check_and_mark_item_reused_(sstable_array.at(0), tablet_handle, tablet_stat))) { + if (OB_FAIL(check_and_mark_item_reused_(sstable_array.at(0).get_sstable(), tablet_handle, tablet_stat))) { LOG_WARN("failed to check and mark item reused", K(ret)); } } else { for (int64_t i = 0; OB_SUCC(ret) && i < sstable_array.count(); ++i) { - if (OB_FAIL(check_and_mark_item_reused_(sstable_array.at(i), tablet_handle, tablet_stat))) { + if (OB_FAIL(check_and_mark_item_reused_(sstable_array.at(i).get_sstable(), tablet_handle, tablet_stat))) { LOG_WARN("failed to check and mark item reused", K(ret)); } } diff --git a/src/storage/backup/ob_backup_utils.cpp b/src/storage/backup/ob_backup_utils.cpp index 6f07dd6f3..1facd05ee 100644 --- a/src/storage/backup/ob_backup_utils.cpp +++ b/src/storage/backup/ob_backup_utils.cpp @@ -78,7 +78,7 @@ int ObBackupUtils::calc_start_replay_scn( } int ObBackupUtils::get_sstables_by_data_type(const storage::ObTabletHandle &tablet_handle, const share::ObBackupDataType &backup_data_type, - const storage::ObTabletTableStore &tablet_table_store, common::ObIArray &sstable_array) + const storage::ObTabletTableStore &tablet_table_store, common::ObIArray &sstable_array) { int ret = OB_SUCCESS; sstable_array.reset(); @@ -90,13 +90,13 @@ int ObBackupUtils::get_sstables_by_data_type(const storage::ObTabletHandle &tabl const storage::ObSSTableArray *major_sstable_array_ptr = NULL; minor_sstable_array_ptr = &tablet_table_store.get_minor_sstables(); major_sstable_array_ptr = &tablet_table_store.get_major_sstables(); - ObArray minor_sstable_array; - ObArray major_sstable_array; - if (OB_FAIL(minor_sstable_array_ptr->get_all_tables(minor_sstable_array))) { + ObArray minor_sstable_array; + ObArray major_sstable_array; + if (OB_FAIL(minor_sstable_array_ptr->get_all_table_wrappers(minor_sstable_array))) { LOG_WARN("failed to get all tables", K(ret), KPC(minor_sstable_array_ptr)); } else if (OB_FAIL(check_tablet_minor_sstable_validity_(tablet_handle, minor_sstable_array))) { LOG_WARN("failed to check tablet minor sstable validity", K(ret), K(tablet_handle), K(minor_sstable_array)); - } else if (OB_FAIL(major_sstable_array_ptr->get_all_tables(major_sstable_array, true/*unpack_table*/))) { + } else if (OB_FAIL(major_sstable_array_ptr->get_all_table_wrappers(major_sstable_array, true/*unpack_table*/))) { LOG_WARN("failed to get all tables", K(ret), KPC(minor_sstable_array_ptr)); } else if (OB_FAIL(append(sstable_array, minor_sstable_array))) { LOG_WARN("failed to append", K(ret), K(minor_sstable_array)); @@ -108,11 +108,11 @@ int ObBackupUtils::get_sstables_by_data_type(const storage::ObTabletHandle &tabl const storage::ObSSTableArray *ddl_sstable_array_ptr = NULL; minor_sstable_array_ptr = &tablet_table_store.get_minor_sstables(); ddl_sstable_array_ptr = &tablet_table_store.get_ddl_sstables(); - ObArray minor_sstable_array; - ObArray ddl_sstable_array; - if (OB_FAIL(minor_sstable_array_ptr->get_all_tables(minor_sstable_array))) { + ObArray minor_sstable_array; + ObArray ddl_sstable_array; + if (OB_FAIL(minor_sstable_array_ptr->get_all_table_wrappers(minor_sstable_array))) { LOG_WARN("failed to get all tables", K(ret), KPC(minor_sstable_array_ptr)); - } else if (OB_FAIL(ddl_sstable_array_ptr->get_all_tables(ddl_sstable_array))) { + } else if (OB_FAIL(ddl_sstable_array_ptr->get_all_table_wrappers(ddl_sstable_array))) { LOG_WARN("failed to get all tables", K(ret), KPC(ddl_sstable_array_ptr)); } else if (OB_FAIL(check_tablet_minor_sstable_validity_(tablet_handle, minor_sstable_array))) { LOG_WARN("failed to check tablet minor sstable validity", K(ret), K(tablet_handle), K(minor_sstable_array)); @@ -130,6 +130,7 @@ int ObBackupUtils::get_sstables_by_data_type(const storage::ObTabletHandle &tabl ObArenaAllocator tmp_allocator("backup_medium", OB_MALLOC_NORMAL_BLOCK_SIZE, MTL_ID()); bool with_major_sstable = true; compaction::ObMediumCompactionInfoList medium_info_list; + ObSSTableWrapper major_wrapper; if (OB_ISNULL(last_major_sstable_ptr = major_sstable_array_ptr->get_boundary_table(true /*last*/))) { if (OB_FAIL(check_tablet_with_major_sstable(tablet_handle, with_major_sstable))) { @@ -150,8 +151,10 @@ int ObBackupUtils::get_sstables_by_data_type(const storage::ObTabletHandle &tabl if (OB_FAIL(static_cast(last_major_sstable_ptr)->get_all_tables(sstable_array))) { LOG_WARN("failed to get all cg tables from co table", K(ret), KPC(last_major_sstable_ptr)); } - } else if (OB_FAIL(sstable_array.push_back(last_major_sstable_ptr))) { - LOG_WARN("failed to push back", K(ret), KPC(last_major_sstable_ptr)); + } else if (OB_FAIL(major_wrapper.set_sstable(static_cast(last_major_sstable_ptr)))) { + LOG_WARN("failed to set major wrapper", K(ret), KPC(last_major_sstable_ptr)); + } else if (OB_FAIL(sstable_array.push_back(major_wrapper))) { + LOG_WARN("failed to push back", K(ret), K(major_wrapper)); } } return ret; @@ -271,7 +274,7 @@ int ObBackupUtils::report_task_result(const int64_t job_id, const int64_t task_i } int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletHandle &tablet_handle, - const common::ObIArray &minor_sstable_array) + const common::ObIArray &minor_sstable_array) { int ret = OB_SUCCESS; ObTablet *tablet = NULL; @@ -299,7 +302,7 @@ int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletH if (OB_FAIL(ret)) { } else if (minor_sstable_array.empty()) { // do nothing - } else if (OB_ISNULL(last_table_ptr = minor_sstable_array.at(minor_sstable_array.count() - 1))) { + } else if (OB_ISNULL(last_table_ptr = minor_sstable_array.at(minor_sstable_array.count() - 1).get_sstable())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("get invalid table ptr", K(ret), K(minor_sstable_array)); } else if (!last_table_ptr->is_minor_sstable()) { @@ -316,7 +319,7 @@ int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletH } int ObBackupUtils::check_tablet_ddl_sstable_validity_(const storage::ObTabletHandle &tablet_handle, - const common::ObIArray &ddl_sstable_array) + const common::ObIArray &ddl_sstable_array) { int ret = OB_SUCCESS; ObTablet *tablet = NULL; @@ -332,7 +335,7 @@ int ObBackupUtils::check_tablet_ddl_sstable_validity_(const storage::ObTabletHan LOG_WARN("invalid tablet handle", K(ret), K(tablet_handle)); } else if (FALSE_IT(ddl_start_scn = tablet->get_tablet_meta().ddl_start_scn_)) { } else if (FALSE_IT(ddl_checkpoint_scn = tablet->get_tablet_meta().ddl_checkpoint_scn_)) { - } else if (OB_ISNULL(last_table_ptr = ddl_sstable_array.at(ddl_sstable_array.count() - 1))) { + } else if (OB_ISNULL(last_table_ptr = ddl_sstable_array.at(ddl_sstable_array.count() - 1).get_sstable())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("get invalid table ptr", K(ret), K(ddl_sstable_array)); } else if (!last_table_ptr->is_ddl_dump_sstable()) { @@ -617,7 +620,7 @@ int ObBackupTabletStat::init(const uint64_t tenant_id, const int64_t backup_set_ int ObBackupTabletStat::prepare_tablet_sstables(const uint64_t tenant_id, const share::ObBackupDataType &backup_data_type, const common::ObTabletID &tablet_id, const storage::ObTabletHandle &tablet_handle, - const common::ObIArray &sstable_array) + const common::ObIArray &sstable_array) { int ret = OB_SUCCESS; ObMutexGuard guard(mutex_); @@ -640,19 +643,18 @@ int ObBackupTabletStat::prepare_tablet_sstables(const uint64_t tenant_id, const } for (int64_t i = 0; OB_SUCC(ret) && i < sstable_array.count(); ++i) { - ObITable *table_ptr = sstable_array.at(i); - if (OB_ISNULL(table_ptr)) { + ObSSTable *sstable_ptr = sstable_array.at(i).get_sstable(); + if (OB_ISNULL(sstable_ptr)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("table ptr should not be null", K(ret), K(i), K(sstable_array)); - } else if (!table_ptr->is_sstable()) { + } else if (!sstable_ptr->is_sstable()) { ret = OB_ERR_UNEXPECTED; - LOG_WARN("table is not sstable", K(ret), KPC(table_ptr)); + LOG_WARN("table is not sstable", K(ret), KPC(sstable_ptr)); } else { // TODO(COLUMN_STORE) Attention !!! MajorSSTable in column store canbe COSSTable, maybe should adapt here. - const ObITable::TableKey &table_key = table_ptr->get_key(); + const ObITable::TableKey &table_key = sstable_ptr->get_key(); ObBackupMacroBlockIDMapping *id_mapping = stat->mappings_.id_map_list_[i]; common::ObArray logic_id_list; - ObSSTable *sstable_ptr = static_cast(table_ptr); if (OB_FAIL(ObBackupUtils::fetch_macro_block_logic_id_list(tablet_handle, *sstable_ptr, logic_id_list))) { LOG_WARN("failed to fetch macro block logic id list", K(ret), K(tablet_handle), KPC(sstable_ptr)); } else if (OB_FAIL(id_mapping->prepare_tablet_sstable(tenant_id, table_key, logic_id_list))) { @@ -1707,7 +1709,7 @@ int ObBackupTabletProvider::prepare_tablet_(const uint64_t tenant_id, const shar { int ret = OB_SUCCESS; total_count = 0; - ObArray sstable_array; + ObArray sstable_array; ObTabletHandle tablet_handle; bool is_normal = false; bool can_explain = false; @@ -1752,19 +1754,13 @@ int ObBackupTabletProvider::prepare_tablet_(const uint64_t tenant_id, const shar } else { for (int64_t i = 0; OB_SUCC(ret) && i < sstable_array.count(); ++i) { int64_t count = 0; - ObITable *table_ptr = sstable_array.at(i); - ObSSTable *sstable = nullptr; - if (OB_ISNULL(table_ptr)) { + ObSSTable *sstable = sstable_array.at(i).get_sstable(); + if (OB_ISNULL(sstable)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("table should not be null", K(ret)); - } else { - // TODO(COLUMN_STORE) Attention !!! MajorSSTable in column store canbe COSSTable, maybe should adapt here. - sstable = static_cast(table_ptr); - } - if (OB_FAIL(ret)) { } else { // TODO(COLUMN_STORE) Attention !!! MajorSSTable in column store canbe COSSTable, maybe should adapt here. - const ObITable::TableKey &table_key = table_ptr->get_key(); + const ObITable::TableKey &table_key = sstable->get_key(); if (OB_FAIL(fetch_all_logic_macro_block_id_(tablet_id, tablet_handle, table_key, *sstable, count))) { LOG_WARN("failed to fetch all logic macro block id", K(ret), K(tablet_id), K(tablet_handle), K(table_key)); } else { @@ -2046,7 +2042,7 @@ int ObBackupTabletProvider::hold_tablet_handle_( int ObBackupTabletProvider::fetch_tablet_sstable_array_(const common::ObTabletID &tablet_id, const storage::ObTabletHandle &tablet_handle, const ObTabletTableStore &table_store, - const share::ObBackupDataType &backup_data_type, common::ObIArray &sstable_array) + const share::ObBackupDataType &backup_data_type, common::ObIArray &sstable_array) { int ret = OB_SUCCESS; sstable_array.reset(); diff --git a/src/storage/backup/ob_backup_utils.h b/src/storage/backup/ob_backup_utils.h index 13645e6bd..ec9dac798 100644 --- a/src/storage/backup/ob_backup_utils.h +++ b/src/storage/backup/ob_backup_utils.h @@ -33,6 +33,7 @@ namespace oceanbase { namespace storage { struct ObBackupLSMetaInfosDesc; +class ObSSTableWrapper; } namespace share { @@ -47,7 +48,7 @@ class ObBackupMacroBlockIndexStore; class ObBackupUtils { public: static int get_sstables_by_data_type(const storage::ObTabletHandle &tablet_handle, const share::ObBackupDataType &backup_data_type, - const storage::ObTabletTableStore &table_store, common::ObIArray &sstable_array); + const storage::ObTabletTableStore &table_store, common::ObIArray &sstable_array); static int check_tablet_with_major_sstable(const storage::ObTabletHandle &tablet_handle, bool &with_major); static int fetch_macro_block_logic_id_list(const storage::ObTabletHandle &tablet_handle, const blocksstable::ObSSTable &sstable, common::ObIArray &logic_id_list); @@ -61,9 +62,9 @@ public: share::SCN &start_replay_scn); private: static int check_tablet_minor_sstable_validity_(const storage::ObTabletHandle &tablet_handle, - const common::ObIArray &minor_sstable_array); + const common::ObIArray &minor_sstable_array); static int check_tablet_ddl_sstable_validity_(const storage::ObTabletHandle &tablet_handle, - const common::ObIArray &ddl_sstable_array); + const common::ObIArray &ddl_sstable_array); static int get_ls_leader_(const uint64_t tenant_id, const share::ObLSID &ls_id, common::ObAddr &leader); static int fetch_ls_member_list_(const uint64_t tenant_id, const share::ObLSID &ls_id, const common::ObAddr &leader_addr, common::ObIArray &addr_list); @@ -100,7 +101,7 @@ public: int init(const uint64_t tenant_id, const int64_t backup_set_id, const share::ObLSID &ls_id, const share::ObBackupDataType &backup_data_type); int prepare_tablet_sstables(const uint64_t tenant_id, const share::ObBackupDataType &backup_data_type, const common::ObTabletID &tablet_id, - const storage::ObTabletHandle &tablet_handle, const common::ObIArray &sstable_array); + const storage::ObTabletHandle &tablet_handle, const common::ObIArray &sstable_array); int mark_items_pending( const share::ObBackupDataType &backup_data_type, const common::ObIArray &items); int mark_items_reused(const share::ObBackupDataType &backup_data_type, @@ -292,7 +293,7 @@ private: int hold_tablet_handle_(const common::ObTabletID &tablet_id, storage::ObTabletHandle &tablet_handle); int fetch_tablet_sstable_array_(const common::ObTabletID &tablet_id, const storage::ObTabletHandle &tablet_handle, const ObTabletTableStore &table_store, const share::ObBackupDataType &backup_data_type, - common::ObIArray &sstable_array); + common::ObIArray &sstable_array); int prepare_tablet_logic_id_reader_(const common::ObTabletID &tablet_id, const storage::ObTabletHandle &tablet_handle, const storage::ObITable::TableKey &table_key, const blocksstable::ObSSTable &sstable, ObITabletLogicMacroIdReader *&reader); diff --git a/src/storage/column_store/ob_cg_aggregated_scanner.cpp b/src/storage/column_store/ob_cg_aggregated_scanner.cpp index c55e8097c..a4e2372c2 100644 --- a/src/storage/column_store/ob_cg_aggregated_scanner.cpp +++ b/src/storage/column_store/ob_cg_aggregated_scanner.cpp @@ -46,13 +46,13 @@ void ObCGAggregatedScanner::reuse() int ObCGAggregatedScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (IS_INIT) { ret = OB_INIT_TWICE; LOG_WARN("The ObCGAggregatedScanner has been inited", K(ret)); - } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.cg_sstable_->is_major_sstable() || + } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.get_sstable()->is_major_sstable() || !iter_param.is_valid())) { ret = OB_INVALID_ARGUMENT; LOG_WARN("Invalid argument", K(ret), K(wrapper), K(iter_param)); diff --git a/src/storage/column_store/ob_cg_aggregated_scanner.h b/src/storage/column_store/ob_cg_aggregated_scanner.h index ecb4cf318..bf8a96cc1 100644 --- a/src/storage/column_store/ob_cg_aggregated_scanner.h +++ b/src/storage/column_store/ob_cg_aggregated_scanner.h @@ -27,7 +27,7 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override final; + ObSSTableWrapper &wrapper) override final; virtual int locate( const ObCSRange &range, const ObCGBitmap *bitmap = nullptr) override final; diff --git a/src/storage/column_store/ob_cg_group_by_scanner.cpp b/src/storage/column_store/ob_cg_group_by_scanner.cpp index ddf6448e7..f1bc4c531 100644 --- a/src/storage/column_store/ob_cg_group_by_scanner.cpp +++ b/src/storage/column_store/ob_cg_group_by_scanner.cpp @@ -38,7 +38,7 @@ void ObCGGroupByScanner::reset() int ObCGGroupByScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (OB_FAIL(ObCGRowScanner::init(iter_param, access_ctx, wrapper))) { diff --git a/src/storage/column_store/ob_cg_group_by_scanner.h b/src/storage/column_store/ob_cg_group_by_scanner.h index bab063219..80225dfbc 100644 --- a/src/storage/column_store/ob_cg_group_by_scanner.h +++ b/src/storage/column_store/ob_cg_group_by_scanner.h @@ -26,7 +26,7 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual ObCGIterType get_type() override { return OB_CG_GROUP_BY_SCANNER; } virtual int init_group_by_info() override; diff --git a/src/storage/column_store/ob_cg_scanner.cpp b/src/storage/column_store/ob_cg_scanner.cpp index fa64ab083..76b7ba29e 100644 --- a/src/storage/column_store/ob_cg_scanner.cpp +++ b/src/storage/column_store/ob_cg_scanner.cpp @@ -26,14 +26,14 @@ ObCGScanner::~ObCGScanner() int ObCGScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (IS_INIT) { ret = OB_INIT_TWICE; LOG_WARN("The ObCGScanner has been inited", K(ret)); - } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.cg_sstable_->is_major_sstable() || + } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.get_sstable()->is_major_sstable() || !iter_param.is_valid())) { ret = OB_INVALID_ARGUMENT; LOG_WARN("Invalid argument to init ObCGScanner", K(ret), K(wrapper), K(iter_param)); @@ -64,14 +64,14 @@ int ObCGScanner::init( int ObCGScanner::switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (IS_NOT_INIT) { ret = OB_NOT_INIT; LOG_WARN("The ObCGScanner is not inited"); - } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.cg_sstable_->is_major_sstable() || + } else if (OB_UNLIKELY(!wrapper.is_valid() || !wrapper.get_sstable()->is_major_sstable() || !iter_param.is_valid())) { ret = OB_INVALID_ARGUMENT; LOG_WARN("Invalid argument", K(ret), K(wrapper), K(iter_param)); @@ -447,7 +447,7 @@ void ObCGRowScanner::reuse() int ObCGRowScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (OB_UNLIKELY(!iter_param.vectorized_enabled_ || nullptr == iter_param.op_ || !wrapper.is_valid() || diff --git a/src/storage/column_store/ob_cg_scanner.h b/src/storage/column_store/ob_cg_scanner.h index 7952ce1e8..17a0db552 100644 --- a/src/storage/column_store/ob_cg_scanner.h +++ b/src/storage/column_store/ob_cg_scanner.h @@ -43,11 +43,11 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual int switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override final; + ObSSTableWrapper &wrapper) override final; virtual void reset() override; virtual void reuse() override; virtual int locate( @@ -103,7 +103,7 @@ protected: ObCSRowId current_; ObCSRange query_index_range_; ObSSTable *sstable_; - ObCGTableWrapper table_wrapper_; + ObSSTableWrapper table_wrapper_; const ObTableIterParam *iter_param_; ObTableAccessContext *access_ctx_; ObCGPrefetcher prefetcher_; @@ -128,7 +128,7 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual int get_next_rows(uint64_t &count, const uint64_t capacity) override; virtual int locate( const ObCSRange &range, diff --git a/src/storage/column_store/ob_cg_sstable_row_getter.cpp b/src/storage/column_store/ob_cg_sstable_row_getter.cpp index af3dc6002..026bbc21e 100644 --- a/src/storage/column_store/ob_cg_sstable_row_getter.cpp +++ b/src/storage/column_store/ob_cg_sstable_row_getter.cpp @@ -48,7 +48,7 @@ void ObCGGetter::reuse() int ObCGGetter::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper, + ObSSTableWrapper &wrapper, const blocksstable::ObDatumRowkey &idx_key) { int ret = OB_SUCCESS; @@ -57,7 +57,7 @@ int ObCGGetter::init( ret = OB_INIT_TWICE; LOG_WARN("The ObCGGetter has been inited", K(ret)); } else if (OB_UNLIKELY(!wrapper.is_valid() || - !wrapper.cg_sstable_->is_normal_cg_sstable() || + !wrapper.get_sstable()->is_normal_cg_sstable() || !iter_param.is_valid() || 1 != idx_key.get_datum_cnt())) { ret = OB_INVALID_ARGUMENT; @@ -334,7 +334,7 @@ int ObCGSSTableRowGetter::prepare_cg_row_getter(const ObCSRowId row_id, const Ob const ObColumnIndexArray &cols_index = read_info->get_columns_index(); int64_t column_cnt = (nullptr == nop_pos) ? iter_param_->get_out_col_cnt() : nop_pos->count(); int64_t column_group_cnt = co_sstable_->get_cs_meta().get_column_group_count(); - ObCGTableWrapper table_wrapper; + ObSSTableWrapper table_wrapper; ObTableIterParam* cg_param = nullptr; int32_t cg_idx = INT32_MAX; row_idx_datum_.reuse(); diff --git a/src/storage/column_store/ob_cg_sstable_row_getter.h b/src/storage/column_store/ob_cg_sstable_row_getter.h index 9a5890f31..668555667 100644 --- a/src/storage/column_store/ob_cg_sstable_row_getter.h +++ b/src/storage/column_store/ob_cg_sstable_row_getter.h @@ -42,7 +42,7 @@ public: int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper, + ObSSTableWrapper &wrapper, const blocksstable::ObDatumRowkey &idx_key); int get_next_row(ObMacroBlockReader &block_reader, const blocksstable::ObDatumRow *&store_row); TO_STRING_KV(K_(is_inited), K_(is_same_data_block), K_(prefetcher), KPC_(sstable)); @@ -51,7 +51,7 @@ protected: bool is_inited_; bool is_same_data_block_; ObSSTable *sstable_; - ObCGTableWrapper table_wrapper_; + ObSSTableWrapper table_wrapper_; const ObTableIterParam *iter_param_; ObTableAccessContext *access_ctx_; ObIndexTreePrefetcher prefetcher_; diff --git a/src/storage/column_store/ob_cg_tile_scanner.cpp b/src/storage/column_store/ob_cg_tile_scanner.cpp index 684eebd04..662235d95 100644 --- a/src/storage/column_store/ob_cg_tile_scanner.cpp +++ b/src/storage/column_store/ob_cg_tile_scanner.cpp @@ -93,7 +93,7 @@ int ObCGTileScanner::switch_context( is_reverse_scan_ = access_ctx.query_flag_.is_reverse_scan(); ObCOSSTableV2 *co_sstable = static_cast(table); for (int64_t i = 0; OB_SUCC(ret) && i < cg_scanners_.count(); i++) { - storage::ObCGTableWrapper cg_wrapper; + storage::ObSSTableWrapper cg_wrapper; const ObTableIterParam &cg_param = *iter_params.at(i); ObICGIterator *&cg_scanner = cg_scanners_.at(i); if (OB_ISNULL(cg_scanner)) { diff --git a/src/storage/column_store/ob_cg_tile_scanner.h b/src/storage/column_store/ob_cg_tile_scanner.h index c6527b3c6..f50309500 100644 --- a/src/storage/column_store/ob_cg_tile_scanner.h +++ b/src/storage/column_store/ob_cg_tile_scanner.h @@ -35,12 +35,12 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override + ObSSTableWrapper &wrapper) override { return OB_NOT_SUPPORTED; } int switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override + ObSSTableWrapper &wrapper) override { return OB_NOT_SUPPORTED; } int init( const ObIArray &iter_params, diff --git a/src/storage/column_store/ob_co_sstable_rows_filter.cpp b/src/storage/column_store/ob_co_sstable_rows_filter.cpp index 0f1ffef4e..5b2a11f6a 100644 --- a/src/storage/column_store/ob_co_sstable_rows_filter.cpp +++ b/src/storage/column_store/ob_co_sstable_rows_filter.cpp @@ -873,7 +873,7 @@ int ObCOSSTableRowsFilter::switch_context_for_cg_iter( ret = OB_INVALID_ARGUMENT; LOG_WARN("Invalid argument", K(ret), KP(co_sstable), K(cg_params.count()), KP(cg_iter)); } else if (1 == cg_params.count()) { - storage::ObCGTableWrapper cg_wrapper; + storage::ObSSTableWrapper cg_wrapper; const ObTableIterParam &cg_param = *cg_params.at(0); if (OB_UNLIKELY(!ObICGIterator::is_valid_cg_scanner(cg_iter->get_type()))) { ret = OB_ERR_UNEXPECTED; diff --git a/src/storage/column_store/ob_column_oriented_merger.cpp b/src/storage/column_store/ob_column_oriented_merger.cpp index ed939c594..9bed4650c 100644 --- a/src/storage/column_store/ob_column_oriented_merger.cpp +++ b/src/storage/column_store/ob_column_oriented_merger.cpp @@ -221,7 +221,7 @@ int ObCOMerger::alloc_writers( } else { ObCOSSTableV2 &co_sstable = static_cast(sstable); for (uint32_t idx = start_cg_idx_; OB_SUCC(ret) && idx < end_cg_idx_; idx++) { - ObCGTableWrapper cg_wrapper; + ObSSTableWrapper cg_wrapper; ObITable *table = nullptr; ObSSTable *cg_sstable = nullptr; const ObStorageColumnGroupSchema &cg_schema = cg_array.at(idx); @@ -244,7 +244,7 @@ int ObCOMerger::alloc_writers( add_column = true; STORAGE_LOG(INFO, "add column for cg", K(ret), K(idx), K(co_sstable.get_cs_meta().column_group_cnt_), K(cg_schema), K(sstable)); } - } else if (OB_FAIL(co_sstable.fetch_cg_sstable(idx, cg_wrapper, true/*fetch_meta*/))) { + } else if (OB_FAIL(co_sstable.fetch_cg_sstable(idx, cg_wrapper))) { STORAGE_LOG(WARN, "failed to get cg sstable", K(ret), K(sstable)); } else if (OB_FAIL(cg_wrapper.get_sstable(cg_sstable))) { STORAGE_LOG(WARN, "failed to get sstable from wrapper", K(ret), K(cg_wrapper)); diff --git a/src/storage/column_store/ob_column_oriented_merger.h b/src/storage/column_store/ob_column_oriented_merger.h index 34ad0576b..6d0532dc8 100644 --- a/src/storage/column_store/ob_column_oriented_merger.h +++ b/src/storage/column_store/ob_column_oriented_merger.h @@ -93,7 +93,7 @@ private: ObPartitionMergeIter *row_store_iter_; ObPartitionMergeProgress *merge_progress_; MERGEWRITERS merge_writers_; - ObSEArray cg_wrappers_; + ObSEArray cg_wrappers_; ObPartitionMergeLoserTreeCmp *cmp_; const uint32_t start_cg_idx_; const uint32_t end_cg_idx_; diff --git a/src/storage/column_store/ob_column_oriented_sstable.cpp b/src/storage/column_store/ob_column_oriented_sstable.cpp index 6b82b9c3b..d1ae7c781 100644 --- a/src/storage/column_store/ob_column_oriented_sstable.cpp +++ b/src/storage/column_store/ob_column_oriented_sstable.cpp @@ -41,49 +41,67 @@ namespace oceanbase namespace storage { -ObCGTableWrapper::ObCGTableWrapper() +ObSSTableWrapper::ObSSTableWrapper() : meta_handle_(), - cg_sstable_(nullptr), - need_meta_(true) + sstable_(nullptr) { } -void ObCGTableWrapper::reset() +void ObSSTableWrapper::reset() { meta_handle_.reset(); - cg_sstable_ = nullptr; - need_meta_ = true; + sstable_ = nullptr; } -bool ObCGTableWrapper::is_valid() const -{ - bool bret = false; - - if (OB_ISNULL(cg_sstable_)) { - } else if (!need_meta_) { - bret = true; - } else if (cg_sstable_->is_loaded() || meta_handle_.is_valid()) { - bret = true; - } - return bret; -} - -int ObCGTableWrapper::get_sstable(ObSSTable *&table) +int ObSSTableWrapper::set_sstable( + ObSSTable *sstable, + ObStorageMetaHandle *meta_handle) { int ret = OB_SUCCESS; + if (OB_UNLIKELY(nullptr == sstable)) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("get invalid argument", K(ret), KPC(sstable), KPC(meta_handle)); + } else if (FALSE_IT(sstable_ = sstable)) { + } else if (nullptr != meta_handle) { + meta_handle_ = *meta_handle; + } + return ret; +} + +int ObSSTableWrapper::get_sstable(ObSSTable *&table) +{ + int ret = OB_SUCCESS; + ObSSTable *meta_sstable = nullptr; + ObSSTableMetaHandle co_meta_handle; if (OB_UNLIKELY(!is_valid())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("wrapper not valid", K(ret), KPC(this)); - } else if (cg_sstable_->is_loaded()) { - table = cg_sstable_; - } else if (OB_FAIL(meta_handle_.get_sstable(table))) { + } else if (sstable_->is_loaded()) { + table = sstable_; + } else if (OB_FAIL(meta_handle_.get_sstable(meta_sstable))) { LOG_WARN("failed to get sstable", K(ret), KPC(this)); + } else if (sstable_->get_key() == meta_sstable->get_key()) { + table = meta_sstable; + } else if (OB_UNLIKELY(!sstable_->is_cg_sstable())) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get unexpected not cg sstable", K(ret), KPC(sstable_), KPC(meta_sstable)); + } else if (OB_FAIL(meta_sstable->get_meta(co_meta_handle))) { + LOG_WARN("failed to get co meta handle", K(ret), KPC(meta_sstable), KPC(sstable_)); + } else { + const ObSSTableArray &cg_sstables = co_meta_handle.get_sstable_meta().get_cg_sstables(); + for (int64_t idx = 0; OB_SUCC(ret) && idx < cg_sstables.count(); ++idx) { + if (sstable_->get_key() == cg_sstables[idx]->get_key()) { + table = cg_sstables[idx]; + break; + } + } } return ret; } +/************************************* ObCOSSTableMeta *************************************/ int64_t ObCOSSTableMeta::get_serialize_size() const { int64_t len = 0; @@ -455,26 +473,24 @@ int ObCOSSTableV2::deep_copy( int ObCOSSTableV2::fetch_cg_sstable( const uint32_t cg_idx, - ObCGTableWrapper &cg_wrapper, - const bool need_meta) + ObSSTableWrapper &cg_wrapper) { int ret = OB_SUCCESS; cg_wrapper.reset(); - cg_wrapper.need_meta_ = need_meta; uint32_t real_cg_idx = cg_idx < cs_meta_.column_group_cnt_ ? cg_idx : key_.column_group_idx_; if (OB_UNLIKELY(is_empty_co_ && real_cg_idx != key_.get_column_group_id())) { ret = OB_STATE_NOT_MATCH; LOG_WARN("co sstable is empty, cannot fetch cg sstable", K(ret), K(cg_idx), K(real_cg_idx), KPC(this)); - } else if (OB_FAIL(get_cg_sstable(real_cg_idx, cg_wrapper.cg_sstable_))) { + } else if (OB_FAIL(get_cg_sstable(real_cg_idx, cg_wrapper))) { LOG_WARN("failed to get cg sstable", K(ret)); - } else if (OB_ISNULL(cg_wrapper.cg_sstable_)) { + } else if (OB_ISNULL(cg_wrapper.sstable_)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("get unexpected null cg table", K(ret), K(cg_wrapper)); - } else if (!need_meta || cg_wrapper.cg_sstable_->is_loaded()) { + } else if (cg_wrapper.sstable_->is_cg_sstable() || cg_wrapper.sstable_->is_loaded()) { // do nothing - } else if (OB_FAIL(ObTabletTableStore::load_sstable(cg_wrapper.cg_sstable_->get_addr(), - false, /*load_co_sstable*/ + } else if (OB_FAIL(ObTabletTableStore::load_sstable(cg_wrapper.sstable_->get_addr(), + true/*load_co_sstable*/, cg_wrapper.meta_handle_))) { LOG_WARN("failed to load sstable", K(ret), K(cg_wrapper)); } @@ -483,11 +499,11 @@ int ObCOSSTableV2::fetch_cg_sstable( int ObCOSSTableV2::get_cg_sstable( const uint32_t cg_idx, - ObSSTable *&cg_sstable) const + ObSSTableWrapper &cg_wrapper) const { int ret = OB_SUCCESS; - cg_sstable = nullptr; - ObSSTableMetaHandle meta_handle; + cg_wrapper.reset(); + ObSSTableMetaHandle co_meta_handle; if (OB_UNLIKELY(!is_cs_valid())) { ret = OB_NOT_INIT; @@ -495,29 +511,50 @@ int ObCOSSTableV2::get_cg_sstable( } else if (cg_idx >= cs_meta_.column_group_cnt_) { ret = OB_INVALID_ARGUMENT; LOG_WARN("get invalid arguments", K(ret), K(cg_idx), K(cs_meta_)); + } else if (OB_FAIL(get_meta(co_meta_handle))) { + LOG_WARN("failed to get co meta handle", K(ret), KPC(this)); } else if (cg_idx == key_.get_column_group_id()) { - cg_sstable = const_cast(this); + cg_wrapper.sstable_ = const_cast(this); } else if (OB_UNLIKELY(is_empty_co_)) { ret = OB_STATE_NOT_MATCH; LOG_WARN("co sstable is empty, cannot fetch normal cg sstable", K(ret), K(cg_idx), KPC(this)); - } else if (OB_FAIL(get_meta(meta_handle))) { - LOG_WARN("failed to get meta handle", K(ret), KPC(this)); } else { - const ObSSTableArray &cg_sstables = meta_handle.get_sstable_meta().get_cg_sstables(); - cg_sstable = cg_idx < key_.column_group_idx_ - ? cg_sstables[cg_idx] - : cg_sstables[cg_idx - 1]; + const ObSSTableArray &cg_sstables = co_meta_handle.get_sstable_meta().get_cg_sstables(); + cg_wrapper.sstable_ = cg_idx < key_.column_group_idx_ + ? cg_sstables[cg_idx] + : cg_sstables[cg_idx - 1]; + } + + if (OB_FAIL(ret)) { + } else if (cg_wrapper.sstable_->is_co_sstable()) { + // do nothing + } else if (cg_wrapper.sstable_->is_loaded()) { + if (co_meta_handle.get_storage_handle().is_valid()) { + // cg sstable lifetime guranteed by co meta handle + cg_wrapper.meta_handle_ = co_meta_handle.get_storage_handle(); + } else { + // co sstable and cg sstable is all loaded, no need to store meta handle + } + } else if (OB_FAIL(ObTabletTableStore::load_sstable(cg_wrapper.sstable_->get_addr(), + false/*load_co_sstable*/, + cg_wrapper.meta_handle_))) { + LOG_WARN("failed to load sstable", K(ret), K(cg_wrapper)); } return ret; } -int ObCOSSTableV2::get_all_tables(common::ObIArray &tables) const +/* + * Returning ObITable* is no longer safe due to the load demand of CG sstable. + */ +int ObCOSSTableV2::get_all_tables(common::ObIArray &table_wrappers) const { int ret = OB_SUCCESS; ObSSTableMetaHandle meta_handle; if (is_empty_co_) { - if (OB_FAIL(tables.push_back(const_cast(this)))) { + ObSSTableWrapper co_wrapper; + co_wrapper.sstable_ = const_cast(this); + if (OB_FAIL(table_wrappers.push_back(co_wrapper))) { LOG_WARN("failed to push back", K(ret), K(is_empty_co_)); } } else if (OB_FAIL(get_meta(meta_handle))) { @@ -525,10 +562,10 @@ int ObCOSSTableV2::get_all_tables(common::ObIArray &tables) const } else { const ObSSTableArray &cg_sstables = meta_handle.get_sstable_meta().get_cg_sstables(); for (int64_t cg_idx = 0; OB_SUCC(ret) && cg_idx <= cg_sstables.count(); ++cg_idx) { - ObSSTable *cg_sstable = nullptr; - if (OB_FAIL(get_cg_sstable(cg_idx, cg_sstable))) { + ObSSTableWrapper cg_wrapper; + if (OB_FAIL(get_cg_sstable(cg_idx, cg_wrapper))) { LOG_WARN("failed to get cg sstable", K(ret), K(cg_idx)); - } else if (OB_FAIL(tables.push_back(cg_sstable))) { + } else if (OB_FAIL(table_wrappers.push_back(cg_wrapper))) { LOG_WARN("failed to push back", K(ret)); } } @@ -629,7 +666,7 @@ int ObCOSSTableV2::cg_scan( int ret = OB_SUCCESS; cg_iter = nullptr; ObICGIterator *cg_scanner = nullptr; - ObCGTableWrapper table_wrapper; + ObSSTableWrapper table_wrapper; if (OB_UNLIKELY(!is_cs_valid())) { ret = OB_ERR_UNEXPECTED; diff --git a/src/storage/column_store/ob_column_oriented_sstable.h b/src/storage/column_store/ob_column_oriented_sstable.h index 21aa20d53..128497ffd 100644 --- a/src/storage/column_store/ob_column_oriented_sstable.h +++ b/src/storage/column_store/ob_column_oriented_sstable.h @@ -31,21 +31,29 @@ namespace storage { class ObTableHandleV2; class ObICGIterator; +class ObCOSSTableV2; -struct ObCGTableWrapper +/* + * ObSSTableWrapper is used for guaranteeing the lifetime of cg sstable + * ONLY CG SSTables need to be guarded by meta_handle + */ +class ObSSTableWrapper { public: - ObCGTableWrapper(); - ~ObCGTableWrapper() { reset(); } + ObSSTableWrapper(); + ~ObSSTableWrapper() { reset(); } void reset(); - bool is_valid() const; + bool is_valid() const { return sstable_ != nullptr; } + int set_sstable(blocksstable::ObSSTable *sstable, ObStorageMetaHandle *meta_handle = nullptr); int get_sstable(blocksstable::ObSSTable *&table); - TO_STRING_KV(K_(need_meta), K_(meta_handle), KPC_(cg_sstable)); -public: - ObStorageMetaHandle meta_handle_; - blocksstable::ObSSTable *cg_sstable_; - bool need_meta_; + blocksstable::ObSSTable *get_sstable() const { return sstable_; } + const ObStorageMetaHandle &get_meta_handle() const { return meta_handle_; } + TO_STRING_KV(KPC_(sstable), K_(meta_handle)); +private: + friend class ObCOSSTableV2; + ObStorageMetaHandle meta_handle_; // keep the lifetime of cg sstable + blocksstable::ObSSTable *sstable_; }; @@ -118,10 +126,9 @@ public: } int fetch_cg_sstable( const uint32_t cg_idx, - ObCGTableWrapper &cg_wrapper, - const bool need_meta = true); - int get_cg_sstable(const uint32_t cg_idx, blocksstable::ObSSTable *&cg_sstable) const; - int get_all_tables(common::ObIArray &tables) const; + ObSSTableWrapper &cg_wrapper); + int get_cg_sstable(const uint32_t cg_idx, ObSSTableWrapper &cg_wrapper) const; + int get_all_tables(common::ObIArray &table_wrappers) const; virtual int64_t get_serialize_size() const override; virtual int serialize(char *buf, const int64_t buf_len, int64_t &pos) const override; diff --git a/src/storage/column_store/ob_i_cg_iterator.h b/src/storage/column_store/ob_i_cg_iterator.h index ac43b87f9..093468ab5 100644 --- a/src/storage/column_store/ob_i_cg_iterator.h +++ b/src/storage/column_store/ob_i_cg_iterator.h @@ -23,7 +23,7 @@ struct PushdownFilterInfo; } namespace storage { -struct ObCGTableWrapper; +class ObSSTableWrapper; class ObGroupByCell; class ObICGIterator @@ -61,14 +61,14 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) = 0; + ObSSTableWrapper &wrapper) = 0; /* * rescan interface */ virtual int switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) = 0; + ObSSTableWrapper &wrapper) = 0; /* * range: locate row index range * bitmap: only used for projection when filter applied diff --git a/src/storage/column_store/ob_virtual_cg_scanner.cpp b/src/storage/column_store/ob_virtual_cg_scanner.cpp index ba4d3703f..6b58d8c26 100644 --- a/src/storage/column_store/ob_virtual_cg_scanner.cpp +++ b/src/storage/column_store/ob_virtual_cg_scanner.cpp @@ -50,7 +50,7 @@ void ObVirtualCGScanner::reuse() int ObVirtualCGScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { UNUSED(wrapper); int ret = OB_SUCCESS; @@ -73,7 +73,7 @@ int ObVirtualCGScanner::init( int ObVirtualCGScanner::switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { UNUSEDx(wrapper); int ret = OB_SUCCESS; @@ -231,7 +231,7 @@ void ObDefaultCGScanner::reuse() int ObDefaultCGScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; @@ -249,7 +249,7 @@ int ObDefaultCGScanner::init( } else if (OB_FAIL(init_cg_agg_cells(iter_param, access_ctx))) { STORAGE_LOG(WARN, "failed to init cg_add_cells", K(ret), K(iter_param), K(access_ctx)); } else { - total_row_count_ = wrapper.cg_sstable_->get_row_count(); + total_row_count_ = wrapper.get_sstable()->get_row_count(); query_range_valid_row_count_ = 0; iter_param_ = &iter_param; filter_ = nullptr; @@ -353,7 +353,7 @@ int ObDefaultCGScanner::init_datum_infos_and_default_row(const ObTableIterParam int ObDefaultCGScanner::switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; @@ -367,7 +367,7 @@ int ObDefaultCGScanner::switch_context( ret = OB_INVALID_ARGUMENT; STORAGE_LOG(WARN, "unexpected argument", K(ret), K(wrapper), K(iter_param), K(access_ctx)); } else { - total_row_count_ = wrapper.cg_sstable_->get_row_count(); + total_row_count_ = wrapper.get_sstable()->get_row_count(); query_range_valid_row_count_ = 0; iter_param_ = &iter_param; stmt_allocator_ = access_ctx.stmt_allocator_; @@ -565,7 +565,7 @@ void ObDefaultCGGroupByScanner::reset() int ObDefaultCGGroupByScanner::init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) + ObSSTableWrapper &wrapper) { int ret = OB_SUCCESS; if (OB_FAIL(ObDefaultCGScanner::init(iter_param, access_ctx, wrapper))) { diff --git a/src/storage/column_store/ob_virtual_cg_scanner.h b/src/storage/column_store/ob_virtual_cg_scanner.h index 352fa466e..6b829d523 100644 --- a/src/storage/column_store/ob_virtual_cg_scanner.h +++ b/src/storage/column_store/ob_virtual_cg_scanner.h @@ -31,11 +31,11 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override final; + ObSSTableWrapper &wrapper) override final; virtual int switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override final; + ObSSTableWrapper &wrapper) override final; virtual int locate( const ObCSRange &range, const ObCGBitmap *bitmap = nullptr) override final; @@ -81,11 +81,11 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual int switch_context( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual int locate( const ObCSRange &range, const ObCGBitmap *bitmap = nullptr) override; @@ -133,7 +133,7 @@ public: virtual int init( const ObTableIterParam &iter_param, ObTableAccessContext &access_ctx, - ObCGTableWrapper &wrapper) override; + ObSSTableWrapper &wrapper) override; virtual int init_group_by_info() override; virtual ObCGIterType get_type() override { return OB_CG_GROUP_BY_SCANNER; } diff --git a/src/storage/compaction/ob_tablet_merge_ctx.cpp b/src/storage/compaction/ob_tablet_merge_ctx.cpp index 93ed016d5..ffb1098c1 100644 --- a/src/storage/compaction/ob_tablet_merge_ctx.cpp +++ b/src/storage/compaction/ob_tablet_merge_ctx.cpp @@ -353,17 +353,17 @@ int ObTabletExeMergeCtx::get_tables_by_key(ObGetMergeTablesResult &get_merge_tab LOG_WARN("failed to assign result", KR(ret)); } else { const ObIArray &table_key_array = exe_dag->get_table_key_array(); - ObITable *table = nullptr; + ObSSTableWrapper sstable_wrapper; for (int64_t i = 0; OB_SUCC(ret) && i < table_key_array.count(); ++i) { const ObITable::TableKey &table_key = table_key_array.at(i); - if (OB_FAIL(table_store_wrapper.get_member()->get_table(table_key, table))) { + if (OB_FAIL(table_store_wrapper.get_member()->get_sstable(table_key, sstable_wrapper))) { if (OB_ENTRY_NOT_EXIST == ret) { ret = OB_NO_NEED_MERGE; } else { LOG_WARN("failed to get table from new table_store", KR(ret)); } - } else if (OB_FAIL(get_merge_table_result.handle_.add_sstable(table, table_store_wrapper.get_meta_handle()))) { - LOG_WARN("failed to add sstable into result", KR(ret), KPC(table)); + } else if (OB_FAIL(get_merge_table_result.handle_.add_sstable(sstable_wrapper.get_sstable(), table_store_wrapper.get_meta_handle()))) { + LOG_WARN("failed to add sstable into result", KR(ret), K(sstable_wrapper)); } } // end of for if (OB_SUCC(ret) && get_merge_table_result.handle_.get_count() != table_key_array.count()) { diff --git a/src/storage/high_availability/ob_storage_ha_dag.cpp b/src/storage/high_availability/ob_storage_ha_dag.cpp index 071ffab70..3d71dadcc 100644 --- a/src/storage/high_availability/ob_storage_ha_dag.cpp +++ b/src/storage/high_availability/ob_storage_ha_dag.cpp @@ -692,8 +692,7 @@ int ObStorageHATaskUtils::check_major_sstable_need_copy_( { int ret = OB_SUCCESS; ObTablet *tablet = nullptr; - const ObSSTable *sstable = nullptr; - ObITable *table = nullptr; + ObSSTableWrapper sstable_wrapper; ObTabletMemberWrapper table_store_wrapper; ObSSTableMetaHandle sst_meta_hdl; @@ -709,15 +708,14 @@ int ObStorageHATaskUtils::check_major_sstable_need_copy_( const ObSSTableArray &major_sstable_array = table_store_wrapper.get_member()->get_major_sstables(); if (major_sstable_array.empty()) { need_copy = true; - } else if (OB_FAIL(major_sstable_array.get_table(param.table_key_, table))) { + } else if (OB_FAIL(major_sstable_array.get_table(param.table_key_, sstable_wrapper))) { LOG_WARN("failed to get table", K(ret), K(param), K(major_sstable_array)); - } else if (nullptr == table) { + } else if (nullptr == sstable_wrapper.get_sstable()) { need_copy = true; - } else if (FALSE_IT(sstable = static_cast(table))) { - } else if (OB_FAIL(sstable->get_meta(sst_meta_hdl))) { + } else if (OB_FAIL(sstable_wrapper.get_sstable()->get_meta(sst_meta_hdl))) { LOG_WARN("failed to get sstable meta handle", K(ret)); } else if (OB_FAIL(ObSSTableMetaChecker::check_sstable_meta(param, sst_meta_hdl.get_sstable_meta()))) { - LOG_WARN("failed to check sstable meta", K(ret), K(param), KPC(sstable)); + LOG_WARN("failed to check sstable meta", K(ret), K(param), K(sstable_wrapper)); } else { need_copy = false; } @@ -781,8 +779,7 @@ int ObStorageHATaskUtils::check_ddl_sstable_need_copy_( { int ret = OB_SUCCESS; ObTablet *tablet = nullptr; - ObITable *table = nullptr; - const ObSSTable *sstable = nullptr; + ObSSTableWrapper sstable_wrapper; ObTabletMemberWrapper table_store_wrapper; ObSSTableMetaHandle sst_meta_hdl; @@ -802,9 +799,9 @@ int ObStorageHATaskUtils::check_ddl_sstable_need_copy_( need_copy = false; } else if (ddl_sstable_array.empty()) { need_copy = true; - } else if (OB_FAIL(ddl_sstable_array.get_table(param.table_key_, table))) { + } else if (OB_FAIL(ddl_sstable_array.get_table(param.table_key_, sstable_wrapper))) { LOG_WARN("failed to get table", K(ret), K(param), K(ddl_sstable_array)); - } else if (nullptr == table) { + } else if (nullptr == sstable_wrapper.get_sstable()) { const SCN start_scn = ddl_sstable_array.get_boundary_table(false)->get_start_scn(); const SCN end_scn = ddl_sstable_array.get_boundary_table(true)->get_end_scn(); if (param.table_key_.scn_range_.start_scn_ >= start_scn @@ -813,11 +810,10 @@ int ObStorageHATaskUtils::check_ddl_sstable_need_copy_( } else { need_copy = true; } - } else if (FALSE_IT(sstable = static_cast(table))) { - } else if (OB_FAIL(sstable->get_meta(sst_meta_hdl))) { + } else if (OB_FAIL(sstable_wrapper.get_sstable()->get_meta(sst_meta_hdl))) { LOG_WARN("failed to get sstable meta handle", K(ret)); } else if (OB_FAIL(ObSSTableMetaChecker::check_sstable_meta(param, sst_meta_hdl.get_sstable_meta()))) { - LOG_WARN("failed to check sstable meta", K(ret), K(param), KPC(sstable)); + LOG_WARN("failed to check sstable meta", K(ret), K(param), K(sstable_wrapper)); } else { need_copy = false; } diff --git a/src/storage/ls/ob_ls_tablet_service.cpp b/src/storage/ls/ob_ls_tablet_service.cpp index d0194face..b64007786 100644 --- a/src/storage/ls/ob_ls_tablet_service.cpp +++ b/src/storage/ls/ob_ls_tablet_service.cpp @@ -5829,12 +5829,12 @@ int ObLSTabletService::estimate_block_count_and_row_count( } if (OB_SUCC(ret) && table->is_co_sstable()) { ObCOSSTableV2 *co_sstable = static_cast(table); - common::ObArray tables; - if (OB_FAIL(co_sstable->get_all_tables(tables))) { + common::ObArray table_wrappers; + if (OB_FAIL(co_sstable->get_all_tables(table_wrappers))) { LOG_WARN("fail to get all tables", K(ret), KPC(co_sstable)); } else { - for (int64_t i = 0; OB_SUCC(ret) && i < tables.count(); i++) { - ObITable *cg_table = tables.at(i); + for (int64_t i = 0; OB_SUCC(ret) && i < table_wrappers.count(); i++) { + ObITable *cg_table = table_wrappers.at(i).get_sstable(); ObSSTableMetaHandle co_sst_meta_hdl; if (OB_UNLIKELY(cg_table == nullptr || !cg_table->is_sstable())) { ret = OB_ERR_UNEXPECTED; diff --git a/src/storage/tablet/ob_table_store_util.cpp b/src/storage/tablet/ob_table_store_util.cpp index fb49e1de2..d8d623669 100644 --- a/src/storage/tablet/ob_table_store_util.cpp +++ b/src/storage/tablet/ob_table_store_util.cpp @@ -513,9 +513,7 @@ ObITable *ObSSTableArray::get_boundary_table(const bool is_last) const return sstable; } -int ObSSTableArray::get_all_tables( - ObIArray &tables, - const bool need_unpack) const +int ObSSTableArray::get_all_tables(ObIArray &tables) const { int ret = OB_SUCCESS; if (OB_UNLIKELY(!is_valid())) { @@ -527,10 +525,6 @@ int ObSSTableArray::get_all_tables( if (OB_ISNULL(table = sstable_array_[i])) { ret = OB_ERR_UNEXPECTED; LOG_WARN("get unexpected null table", K(ret)); - } else if (table->is_co_sstable() && need_unpack) { - if (OB_FAIL(static_cast(table)->get_all_tables(tables))) { - LOG_WARN("failed to get all cg tables from co table", K(ret), KPC(table)); - } } else if (OB_FAIL(tables.push_back(table))) { LOG_WARN("fail to push sstable address into array", K(ret), K(i), K(tables)); } @@ -539,10 +533,42 @@ int ObSSTableArray::get_all_tables( return ret; } -int ObSSTableArray::get_table(const ObITable::TableKey &table_key, ObITable *&table) const +int ObSSTableArray::get_all_table_wrappers( + ObIArray &table_wrappers, + const bool need_unpack) const { int ret = OB_SUCCESS; - table = nullptr; + if (OB_UNLIKELY(!is_valid())) { + ret = OB_NOT_INIT; + LOG_WARN("not init", K(ret)); + } else { + ObSSTable *table = nullptr; + for (int64_t i = 0; OB_SUCC(ret) && i < cnt_; ++i) { + ObSSTableWrapper wrapper; + if (OB_ISNULL(table = sstable_array_[i])) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("get unexpected null table", K(ret)); + } else if (table->is_co_sstable() && need_unpack) { + if (OB_FAIL(static_cast(table)->get_all_tables(table_wrappers))) { + LOG_WARN("failed to get all cg tables from co table", K(ret), KPC(table)); + } + } else if (OB_FAIL(wrapper.set_sstable(table))) { + LOG_WARN("failed to set sstable", K(ret), KPC(table)); + } else if (OB_FAIL(table_wrappers.push_back(wrapper))) { + LOG_WARN("fail to push sstable address into array", K(ret), K(i), K(table_wrappers)); + } + } + } + return ret; +} + +int ObSSTableArray::get_table( + const ObITable::TableKey &table_key, + ObSSTableWrapper &wrapper) const +{ + int ret = OB_SUCCESS; + wrapper.reset(); + if (OB_UNLIKELY(!is_valid())) { ret = OB_NOT_INIT; LOG_WARN("not init", K(ret), K(table_key)); @@ -551,14 +577,13 @@ int ObSSTableArray::get_table(const ObITable::TableKey &table_key, ObITable *&ta LOG_WARN("invalid table key", K(ret), K(table_key)); } - ObITable *cur_table = nullptr; + ObSSTable *cur_table = nullptr; for (int64_t i = 0; OB_SUCC(ret) && i < cnt_; ++i) { if (OB_ISNULL(cur_table = sstable_array_[i])) { ret = OB_ERR_UNEXPECTED; LOG_WARN("unexpected null sstable pointer", K(ret), KPC(this)); } else if (table_key.is_cg_sstable()) { // should get cg table from co sstable ObCOSSTableV2 *co_sstable = nullptr; - ObSSTable *cg_sstable = nullptr; if (table_key.get_snapshot_version() != cur_table->get_snapshot_version()) { // do nothing } else if (OB_UNLIKELY(!cur_table->is_co_sstable())) { @@ -569,14 +594,15 @@ int ObSSTableArray::get_table(const ObITable::TableKey &table_key, ObITable *&ta ret = OB_ERR_UNEXPECTED; LOG_WARN("empty co table has no cg table", K(ret), K(table_key), KPC(co_sstable), KPC(this)); ob_abort(); // tmp debug code - } else if (OB_FAIL(co_sstable->get_cg_sstable(table_key.get_column_group_id(), cg_sstable))) { + } else if (OB_FAIL(co_sstable->get_cg_sstable(table_key.get_column_group_id(), wrapper))) { LOG_WARN("failed to get cg table from co sstable", K(ret), K(table_key), KPC(co_sstable)); } else { - table = cg_sstable; break; } } else if (table_key == cur_table->get_key()) { - table = cur_table; + if (OB_FAIL(wrapper.set_sstable(cur_table))) { + LOG_WARN("failed to set sstable", K(ret), KPC(cur_table)); + } break; } } diff --git a/src/storage/tablet/ob_table_store_util.h b/src/storage/tablet/ob_table_store_util.h index d6b258240..b4de3cd55 100644 --- a/src/storage/tablet/ob_table_store_util.h +++ b/src/storage/tablet/ob_table_store_util.h @@ -28,6 +28,7 @@ class ObTabletTableStore; class ObTabletTablesSet; class ObTenantMetaMemMgr; class ObITableArray; +class ObSSTableWrapper; class ObSSTableArray { @@ -70,8 +71,9 @@ public: blocksstable::ObSSTable *operator[](const int64_t pos) const; blocksstable::ObSSTable *at(const int64_t pos) const; ObITable *get_boundary_table(const bool is_last) const; - int get_all_tables(ObIArray &tables, const bool need_unpack = false) const; - int get_table(const ObITable::TableKey &table_key, ObITable *&table) const; + int get_all_tables(ObIArray &tables) const; + int get_all_table_wrappers(ObIArray &tables, const bool need_unpack = false) const; + int get_table(const ObITable::TableKey &table_key, ObSSTableWrapper &wrapper) const; int inc_macro_ref(bool &is_success) const; void dec_macro_ref() const; diff --git a/src/storage/tablet/ob_tablet.cpp b/src/storage/tablet/ob_tablet.cpp index 7afc77954..29d3f1d2c 100644 --- a/src/storage/tablet/ob_tablet.cpp +++ b/src/storage/tablet/ob_tablet.cpp @@ -7155,18 +7155,17 @@ int ObTablet::get_column_store_sstable_checksum(common::ObIArray &colum if (OB_FAIL(ret)) { } else if (!co_sstable.is_empty_co_table()) { - ObSSTable *cg_sstable = nullptr; - common::ObArray cg_tables; + common::ObArray cg_tables; if (OB_FAIL(co_sstable.get_all_tables(cg_tables))) { LOG_WARN("fail to get_all_tables", K(ret)); } else { ObSSTableMetaHandle cg_table_meta_hdl; for (int64_t i = 0; i < cg_tables.count() && OB_SUCC(ret); i++) { - if (OB_UNLIKELY(nullptr == cg_tables.at(i) || !cg_tables.at(i)->is_sstable())) { + const ObSSTable *cg_sstable = cg_tables.at(i).get_sstable(); + if (OB_UNLIKELY(nullptr == cg_sstable || !cg_sstable->is_sstable())) { ret = OB_ERR_UNEXPECTED; - LOG_WARN("unexpected cg table", K(ret), K(cg_tables.at(i))); + LOG_WARN("unexpected cg table", K(ret), KPC(cg_sstable)); } else { - const ObSSTable *cg_sstable = static_cast(cg_tables.at(i)); const uint32_t cg_idx = cg_sstable->get_key().get_column_group_id(); const ObStorageColumnGroupSchema &column_group = column_groups.at(cg_idx); if (OB_FAIL(cg_sstable->get_meta(cg_table_meta_hdl))) { diff --git a/src/storage/tablet/ob_tablet_table_store.cpp b/src/storage/tablet/ob_tablet_table_store.cpp index ab6b02de8..bf3754334 100644 --- a/src/storage/tablet/ob_tablet_table_store.cpp +++ b/src/storage/tablet/ob_tablet_table_store.cpp @@ -369,13 +369,13 @@ int ObTabletTableStore::inner_replace_sstables( { int ret = OB_SUCCESS; // check table key first - ObITable *tmp_table = nullptr; + ObSSTableWrapper tmp_wrapper; for (int64_t i = 0; OB_SUCC(ret) && i < replace_sstable_array.count(); ++i) { const ObITable *table = replace_sstable_array.at(i); if (OB_UNLIKELY(nullptr == table || !table->is_sstable())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("table must be sstable", K(ret), KPC(table)); - } else if (OB_FAIL(old_store.get_table(table->get_key(), tmp_table))) { + } else if (OB_FAIL(old_store.get_sstable(table->get_key(), tmp_wrapper))) { LOG_WARN("failed to get the same key sstable in old store", K(ret), KPC(table), K(old_store)); } } @@ -823,11 +823,22 @@ int ObTabletTableStore::get_table( int ret = OB_SUCCESS; handle.reset(); ObITable *table = nullptr; + ObSSTableWrapper sstable_wrapper; + if (OB_UNLIKELY(!is_valid())) { ret = OB_ERR_UNEXPECTED; LOG_WARN("table store is unexpected invalid", K(ret), KPC(this)); - } else if (OB_FAIL(get_table(table_key, table))) { - LOG_WARN("fail to get table pointer", K(ret)); + } else if (!table_key.is_memtable()) { + if (OB_FAIL(get_sstable(table_key, sstable_wrapper))) { + LOG_WARN("fail to get sstable wrapper", K(ret), K(table_key)); + } else { + table = sstable_wrapper.get_sstable(); + } + } else if (OB_FAIL(get_memtable(table_key, table))) { + LOG_WARN("fail to get memtable pointer", K(ret), K(table_key)); + } + + if (OB_FAIL(ret)) { } else if (OB_ISNULL(table)) { ret = OB_ERR_UNEXPECTED; LOG_WARN("found null table pointer", K(ret), K(table_key)); @@ -837,7 +848,11 @@ int ObTabletTableStore::get_table( LOG_WARN("Failed to set memtable to handle", K(ret), K(handle), K(table_key), KPC(table)); } } else if (static_cast(table)->is_loaded()) { - if (!table_store_handle.is_valid()) { + if (table->is_cg_sstable() && sstable_wrapper.get_meta_handle().is_valid()) { + if ( OB_FAIL(handle.set_sstable(sstable_wrapper.get_sstable(), sstable_wrapper.get_meta_handle()))) { + LOG_WARN("fail to set cg sstable to handle", K(ret), K(sstable_wrapper)); + } + } else if (!table_store_handle.is_valid()) { // table store object on tablet meta memory if (OB_FAIL(handle.set_sstable_with_tablet(table))) { LOG_WARN("failed to set sstable to handle", K(ret)); @@ -862,14 +877,14 @@ int ObTabletTableStore::get_table( return ret; } -int ObTabletTableStore::get_table(const ObITable::TableKey &table_key, ObITable *&table) const +int ObTabletTableStore::get_sstable(const ObITable::TableKey &table_key, ObSSTableWrapper &wrapper) const { int ret = OB_SUCCESS; - if (OB_UNLIKELY(!table_key.is_valid())) { + if (OB_UNLIKELY(!table_key.is_valid() || table_key.is_memtable())) { ret = OB_INVALID_ARGUMENT; LOG_WARN("invalid arguments", K(ret), K(table_key)); } else { - table = nullptr; + wrapper.reset(); const ObSSTableArray *sst_array = nullptr; if (table_key.is_major_sstable()) { sst_array = table_key.is_meta_major_sstable() @@ -881,18 +896,37 @@ int ObTabletTableStore::get_table(const ObITable::TableKey &table_key, ObITable sst_array = &ddl_sstables_; } + if (OB_ISNULL(sst_array)) { + ret = OB_ERR_UNEXPECTED; + LOG_WARN("unexpected null sstable array", K(ret), K(table_key)); + } else if (sst_array->empty()) { + // not found + } else if (OB_FAIL(sst_array->get_table(table_key, wrapper))) { + LOG_WARN("fail to get table from sstable array", K(ret)); + } + + if (OB_FAIL(ret)) { + } else if (OB_ISNULL(wrapper.get_sstable())) { + ret = OB_ENTRY_NOT_EXIST; + LOG_WARN("table not found", K(ret), K(table_key)); + } + } + return ret; +} + +int ObTabletTableStore::get_memtable(const ObITable::TableKey &table_key, ObITable *&table) const +{ + int ret = OB_SUCCESS; + if (OB_UNLIKELY(!table_key.is_valid() && !table_key.is_memtable())) { + ret = OB_INVALID_ARGUMENT; + LOG_WARN("invalid arguments", K(ret), K(table_key)); + } else { + table = nullptr; if (table_key.is_memtable()) { common::SpinRLockGuard guard(memtables_lock_); if (OB_FAIL(memtables_.find(table_key, table))) { LOG_WARN("fail to get memtable", K(ret), K(table_key), K_(memtables)); } - } else if (OB_ISNULL(sst_array)) { - ret = OB_ERR_UNEXPECTED; - LOG_WARN("unexpected null sstable array", K(ret), K(table_key)); - } else if (sst_array->empty()) { - // not found - } else if (OB_FAIL(sst_array->get_table(table_key, table))) { - LOG_WARN("fail to get table from sstable array", K(ret)); } if (OB_FAIL(ret)) { diff --git a/src/storage/tablet/ob_tablet_table_store.h b/src/storage/tablet/ob_tablet_table_store.h index 594c27d95..dce6c0e8e 100644 --- a/src/storage/tablet/ob_tablet_table_store.h +++ b/src/storage/tablet/ob_tablet_table_store.h @@ -109,7 +109,8 @@ public: const ObStorageMetaHandle &table_store_handle, const ObITable::TableKey &table_key, ObTableHandleV2 &handle) const; - int get_table(const ObITable::TableKey &table_key, ObITable *&table) const; + int get_sstable(const ObITable::TableKey &table_key, ObSSTableWrapper &wrapper) const; + int get_memtable(const ObITable::TableKey &table_key, ObITable *&table) const; int get_read_tables( const int64_t snapshot_version, const ObTablet &tablet, diff --git a/unittest/storage/column_store/test_co_sstable.cpp b/unittest/storage/column_store/test_co_sstable.cpp index ee0b64e67..f5823a2d1 100644 --- a/unittest/storage/column_store/test_co_sstable.cpp +++ b/unittest/storage/column_store/test_co_sstable.cpp @@ -334,19 +334,19 @@ TEST_F(TestCOSSTable, get_cg_table_test) EXPECT_EQ(true, co_sstable->valid_for_cs_reading_); - ObSSTable *get_cg_table1 = nullptr; + ObSSTableWrapper get_cg_table1; ret = co_sstable->get_cg_sstable(1, get_cg_table1); - EXPECT_EQ(co_sstable->key_.column_group_idx_, get_cg_table1->key_.column_group_idx_); + EXPECT_EQ(co_sstable->key_.column_group_idx_, get_cg_table1.sstable_->key_.column_group_idx_); - ObSSTable *get_cg_table2 = nullptr; + ObSSTableWrapper get_cg_table2; ret = co_sstable->get_cg_sstable(0, get_cg_table2); - EXPECT_EQ(cg_table1->key_.column_group_idx_, get_cg_table2->key_.column_group_idx_); + EXPECT_EQ(cg_table1->key_.column_group_idx_, get_cg_table2.sstable_->key_.column_group_idx_); - ObSSTable *get_cg_table3 = nullptr; + ObSSTableWrapper get_cg_table3; ret = co_sstable->get_cg_sstable(2, get_cg_table3); - EXPECT_EQ(cg_table2->key_.column_group_idx_, get_cg_table3->key_.column_group_idx_); + EXPECT_EQ(cg_table2->key_.column_group_idx_, get_cg_table3.sstable_->key_.column_group_idx_); - ObSSTable *get_cg_table4 = nullptr; + ObSSTableWrapper get_cg_table4; ret = co_sstable->get_cg_sstable(3, get_cg_table4); EXPECT_EQ(OB_INVALID_ARGUMENT, ret); }