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

return ObSSTableWrapper instead of ObITable* when getting cg sstable from co sstable

Browse Source
This commit is contained in:
Fengjingkun 2023-12-07 10:12:57 +00:00 committed by ob-robot
parent 4f13ffea18
commit 62d265e263
35 changed files with 350 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
mittest/mtlenv/storage/blocksstable/test_cg_group_by_scanner.cpp
View File

@ -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());

16
mittest/mtlenv/storage/blocksstable/test_cg_scanner.cpp
View File

@ -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;

28
mittest/mtlenv/storage/blocksstable/test_cs_cg_group_by_scanner.cpp
View File

@ -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());

18
src/storage/backup/ob_backup_reader.cpp
View File

@ -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<ObSSTable *>(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))) {

2
src/storage/backup/ob_backup_reader.h
View File

@ -269,7 +269,7 @@ private:
int get_macro_block_id_list_(const blocksstable::ObSSTable &sstable, ObBackupSSTableMeta &sstable_meta);
private:
common::ObArray<storage::ObITable *> sstable_array_;
common::ObArray<storage::ObSSTableWrapper> sstable_array_;
blocksstable::ObSelfBufferWriter buffer_writer_;
ObTabletMemberWrapper<ObTabletTableStore> table_store_wrapper_;
DISALLOW_COPY_AND_ASSIGN(ObSSTableMetaBackupReader);

6
src/storage/backup/ob_backup_task.cpp
View File

@ -3432,7 +3432,7 @@ int ObLSBackupDataTask::may_fill_reused_backup_items_(
ObTabletMemberWrapper<ObTabletTableStore> table_store_wrapper;
ObBackupDataType backup_data_type;
backup_data_type.set_major_data_backup();
ObArray<ObITable *> sstable_array;
ObArray<ObSSTableWrapper> 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));
}
}

62
src/storage/backup/ob_backup_utils.cpp
View File

@ -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<storage::ObITable *> &sstable_array)
const storage::ObTabletTableStore &tablet_table_store, common::ObIArray<storage::ObSSTableWrapper> &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<storage::ObITable *> minor_sstable_array;
ObArray<storage::ObITable *> major_sstable_array;
if (OB_FAIL(minor_sstable_array_ptr->get_all_tables(minor_sstable_array))) {
ObArray<storage::ObSSTableWrapper> minor_sstable_array;
ObArray<storage::ObSSTableWrapper> 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<storage::ObITable *> minor_sstable_array;
ObArray<storage::ObITable *> ddl_sstable_array;
if (OB_FAIL(minor_sstable_array_ptr->get_all_tables(minor_sstable_array))) {
ObArray<storage::ObSSTableWrapper> minor_sstable_array;
ObArray<storage::ObSSTableWrapper> 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<ObCOSSTableV2 *>(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<ObSSTable *>(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<storage::ObITable *> &minor_sstable_array)
const common::ObIArray<storage::ObSSTableWrapper> &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<storage::ObITable *> &ddl_sstable_array)
const common::ObIArray<storage::ObSSTableWrapper> &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<storage::ObITable *> &sstable_array)
const common::ObIArray<storage::ObSSTableWrapper> &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<ObLogicMacroBlockId> logic_id_list;
ObSSTable *sstable_ptr = static_cast<ObSSTable *>(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<storage::ObITable *> sstable_array;
ObArray<storage::ObSSTableWrapper> 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<ObSSTable *>(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<storage::ObITable *> &sstable_array)
const share::ObBackupDataType &backup_data_type, common::ObIArray<storage::ObSSTableWrapper> &sstable_array)
{
int ret = OB_SUCCESS;
sstable_array.reset();

11
src/storage/backup/ob_backup_utils.h
View File

@ -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<storage::ObITable *> &sstable_array);
const storage::ObTabletTableStore &table_store, common::ObIArray<storage::ObSSTableWrapper> &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<blocksstable::ObLogicMacroBlockId> &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<storage::ObITable *> &minor_sstable_array);
const common::ObIArray<storage::ObSSTableWrapper> &minor_sstable_array);
static int check_tablet_ddl_sstable_validity_(const storage::ObTabletHandle &tablet_handle,
const common::ObIArray<storage::ObITable *> &ddl_sstable_array);
const common::ObIArray<storage::ObSSTableWrapper> &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<common::ObAddr> &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<storage::ObITable *> &sstable_array);
const storage::ObTabletHandle &tablet_handle, const common::ObIArray<storage::ObSSTableWrapper> &sstable_array);
int mark_items_pending(
const share::ObBackupDataType &backup_data_type, const common::ObIArray<ObBackupProviderItem> &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<storage::ObITable *> &sstable_array);
common::ObIArray<storage::ObSSTableWrapper> &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);

4
src/storage/column_store/ob_cg_aggregated_scanner.cpp
View File

@ -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));

2
src/storage/column_store/ob_cg_aggregated_scanner.h
View File

@ -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;

2
src/storage/column_store/ob_cg_group_by_scanner.cpp
View File

@ -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))) {

2
src/storage/column_store/ob_cg_group_by_scanner.h
View File

@ -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;

10
src/storage/column_store/ob_cg_scanner.cpp
View File

@ -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() ||

8
src/storage/column_store/ob_cg_scanner.h
View File

@ -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,

6
src/storage/column_store/ob_cg_sstable_row_getter.cpp
View File

@ -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();

4
src/storage/column_store/ob_cg_sstable_row_getter.h
View File

@ -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_;

2
src/storage/column_store/ob_cg_tile_scanner.cpp
View File

@ -93,7 +93,7 @@ int ObCGTileScanner::switch_context(
is_reverse_scan_ = access_ctx.query_flag_.is_reverse_scan();
ObCOSSTableV2 *co_sstable = static_cast<ObCOSSTableV2 *>(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)) {

4
src/storage/column_store/ob_cg_tile_scanner.h
View File

@ -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<ObTableIterParam*> &iter_params,

2
src/storage/column_store/ob_co_sstable_rows_filter.cpp
View File

@ -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;

4
src/storage/column_store/ob_column_oriented_merger.cpp
View File

@ -221,7 +221,7 @@ int ObCOMerger::alloc_writers(
} else {
ObCOSSTableV2 &co_sstable = static_cast<ObCOSSTableV2 &>(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));

2
src/storage/column_store/ob_column_oriented_merger.h
View File

@ -93,7 +93,7 @@ private:
ObPartitionMergeIter *row_store_iter_;
ObPartitionMergeProgress *merge_progress_;
MERGEWRITERS merge_writers_;
ObSEArray<storage::ObCGTableWrapper, 16, common::ObIAllocator&> cg_wrappers_;
ObSEArray<storage::ObSSTableWrapper, 16, common::ObIAllocator&> cg_wrappers_;
ObPartitionMergeLoserTreeCmp *cmp_;
const uint32_t start_cg_idx_;
const uint32_t end_cg_idx_;

131
src/storage/column_store/ob_column_oriented_sstable.cpp
View File

@ -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<ObCOSSTableV2 *>(this);
cg_wrapper.sstable_ = const_cast<ObCOSSTableV2 *>(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<ObITable *> &tables) const
/*
* Returning ObITable* is no longer safe due to the load demand of CG sstable.
*/
int ObCOSSTableV2::get_all_tables(common::ObIArray<ObSSTableWrapper> &table_wrappers) const
{
int ret = OB_SUCCESS;
ObSSTableMetaHandle meta_handle;
if (is_empty_co_) {
if (OB_FAIL(tables.push_back(const_cast<ObCOSSTableV2 *>(this)))) {
ObSSTableWrapper co_wrapper;
co_wrapper.sstable_ = const_cast<ObCOSSTableV2 *>(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<ObITable *> &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;

33
src/storage/column_store/ob_column_oriented_sstable.h
View File

@ -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<ObITable *> &tables) const;
ObSSTableWrapper &cg_wrapper);
int get_cg_sstable(const uint32_t cg_idx, ObSSTableWrapper &cg_wrapper) const;
int get_all_tables(common::ObIArray<ObSSTableWrapper> &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;

6
src/storage/column_store/ob_i_cg_iterator.h
View File

@ -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

14
src/storage/column_store/ob_virtual_cg_scanner.cpp
View File

@ -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))) {

10
src/storage/column_store/ob_virtual_cg_scanner.h
View File

@ -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; }

8
src/storage/compaction/ob_tablet_merge_ctx.cpp
View File

@ -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<ObITable::TableKey> &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()) {

24
src/storage/high_availability/ob_storage_ha_dag.cpp
View File

@ -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<ObTabletTableStore> 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<ObSSTable *>(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<ObTabletTableStore> 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<ObSSTable *>(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;
}

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

@ -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<ObCOSSTableV2 *>(table);
common::ObArray<ObITable *> tables;
if (OB_FAIL(co_sstable->get_all_tables(tables))) {
common::ObArray<ObSSTableWrapper> 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;

54
src/storage/tablet/ob_table_store_util.cpp
View File

@ -513,9 +513,7 @@ ObITable *ObSSTableArray::get_boundary_table(const bool is_last) const
return sstable;
}
int ObSSTableArray::get_all_tables(
ObIArray<ObITable *> &tables,
const bool need_unpack) const
int ObSSTableArray::get_all_tables(ObIArray<ObITable *> &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<ObCOSSTableV2 *>(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<ObSSTableWrapper> &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<ObCOSSTableV2 *>(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;
}
}

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

@ -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<ObITable *> &tables, const bool need_unpack = false) const;
int get_table(const ObITable::TableKey &table_key, ObITable *&table) const;
int get_all_tables(ObIArray<ObITable *> &tables) const;
int get_all_table_wrappers(ObIArray<ObSSTableWrapper> &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;

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

@ -7155,18 +7155,17 @@ int ObTablet::get_column_store_sstable_checksum(common::ObIArray<int64_t> &colum
if (OB_FAIL(ret)) {
} else if (!co_sstable.is_empty_co_table()) {
ObSSTable *cg_sstable = nullptr;
common::ObArray<ObITable *> cg_tables;
common::ObArray<ObSSTableWrapper> 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<ObSSTable *>(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))) {

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

@ -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<ObSSTable *>(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)) {

3
src/storage/tablet/ob_tablet_table_store.h
View File

@ -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,

14
unittest/storage/column_store/test_co_sstable.cpp
View File

@ -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);
}