From 2d98a71efa8e123cdf39f8df44a4fc2d87a27a47 Mon Sep 17 00:00:00 2001 From: renju96 Date: Thu, 8 Feb 2024 12:00:54 +0000 Subject: [PATCH] fix offset from DDLKV && fix wrong read_info --- .../ob_index_block_data_prepare.h | 55 ++- .../blocksstable/test_merge_cg_scanner.cpp | 402 ++++++++++++++++++ .../ob_ddl_index_block_row_iterator.cpp | 28 +- .../ob_ddl_index_block_row_iterator.h | 4 +- .../ob_sstable_sec_meta_iterator.cpp | 3 +- src/storage/ddl/ob_tablet_ddl_kv.cpp | 3 +- 6 files changed, 482 insertions(+), 13 deletions(-) create mode 100644 mittest/mtlenv/storage/blocksstable/test_merge_cg_scanner.cpp diff --git a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h index adf303c2f6..d01e207845 100644 --- a/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h +++ b/mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h @@ -1,5 +1,5 @@ /** - * Copyright (c) 2021 OceanBase + * Copyright (c) 2023 OceanBase * OceanBase CE is licensed under Mulan PubL v2. * You can use this software according to the terms and conditions of the Mulan PubL v2. * You may obtain a copy of Mulan PubL v2 at: @@ -65,6 +65,7 @@ public: virtual void prepare_schema(); virtual void prepare_data(const int64_t micro_block_size = 0); virtual void prepare_partial_ddl_data(); + virtual void prepare_partial_cg_data(); virtual void prepare_cg_data(); virtual void insert_data(ObMacroBlockWriter &data_writer); // override to define data in sstable virtual void insert_cg_data(ObMacroBlockWriter &data_writer); // override to define data in sstable @@ -297,12 +298,15 @@ void TestIndexBlockDataPrepare::SetUp() ASSERT_EQ(OB_SUCCESS, TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema_, allocator_)); ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet(tablet_id, tablet_handle_)); sstable_.key_.table_type_ = ObITable::TableType::COLUMN_ORIENTED_SSTABLE; - partial_sstable_.key_.table_type_ = ObITable::TableType::DDL_MERGE_CO_SSTABLE; - if (is_cg_data_) { + if (is_cg_data_ && is_ddl_merge_data_) { + prepare_partial_cg_data(); + partial_sstable_.key_.table_type_ = ObITable::TableType::DDL_MERGE_CG_SSTABLE; + } else if (is_cg_data_) { prepare_cg_data(); } else if (is_ddl_merge_data_) { prepare_partial_ddl_data(); + partial_sstable_.key_.table_type_ = ObITable::TableType::DDL_MERGE_CO_SSTABLE; } else { prepare_data(); } @@ -888,6 +892,51 @@ void TestIndexBlockDataPrepare::prepare_partial_ddl_data() ObTabletObjLoadHelper::free(allocator_, storage_schema); } +void TestIndexBlockDataPrepare::prepare_partial_cg_data() +{ + prepare_contrastive_sstable(); + ObMacroBlockWriter writer; + ObMacroDataSeq start_seq(0); + start_seq.set_data_block(); + row_generate_.reset(); + ObWholeDataStoreDesc desc(true/*is ddl*/); + share::SCN end_scn; + end_scn.convert_from_ts(ObTimeUtility::current_time()); + ASSERT_EQ(OB_SUCCESS, desc.init(table_schema_, ObLSID(ls_id_), ObTabletID(tablet_id_), merge_type_, SNAPSHOT_VERSION, CLUSTER_CURRENT_VERSION, end_scn)); + void *builder_buf = allocator_.alloc(sizeof(ObSSTableIndexBuilder)); + merge_root_index_builder_ = new (builder_buf) ObSSTableIndexBuilder(); + ASSERT_NE(nullptr, merge_root_index_builder_); + desc.get_desc().sstable_index_builder_ = merge_root_index_builder_; + ASSERT_TRUE(desc.is_valid()); + if (need_agg_data_) { + ASSERT_EQ(OB_SUCCESS, desc.get_desc().col_desc_->agg_meta_array_.assign(agg_col_metas_)); + } + ASSERT_EQ(OB_SUCCESS, merge_root_index_builder_->init(desc.get_desc())); + ASSERT_EQ(OB_SUCCESS, writer.open(desc.get_desc(), start_seq)); + ASSERT_EQ(OB_SUCCESS, row_generate_.init(table_schema_, &allocator_)); + const int64_t partial_row_cnt = max_partial_row_cnt_; + insert_partial_data(writer, partial_row_cnt); + ASSERT_EQ(OB_SUCCESS, writer.close()); + // data write ctx has been moved to merge_root_index_builder_ + ASSERT_EQ(writer.get_macro_block_write_ctx().get_macro_block_count(), 0); + data_macro_block_cnt_ = merge_root_index_builder_->roots_[0]->macro_metas_->count(); + ASSERT_GE(data_macro_block_cnt_, 0); + int64_t column_cnt = 0; + ObTabletID tablet_id(TestIndexBlockDataPrepare::tablet_id_); + ObLSID ls_id(ls_id_); + ObLSHandle ls_handle; + ObTabletHandle tablet_handle; + ObLSService *ls_svr = MTL(ObLSService*); + ObStorageSchema *storage_schema = nullptr; + ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD)); + ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet(tablet_id, tablet_handle)); + ASSERT_EQ(OB_SUCCESS, tablet_handle.get_obj()->load_storage_schema(allocator_, storage_schema)); + ASSERT_EQ(OB_SUCCESS, storage_schema->get_stored_column_count_in_sstable(column_cnt)); + prepare_partial_sstable(column_cnt); + prepare_merge_ddl_kvs(); + ObTabletObjLoadHelper::free(allocator_, storage_schema); +} + void TestIndexBlockDataPrepare::prepare_partial_sstable(const int64_t column_cnt) { ObSSTableMergeRes res; diff --git a/mittest/mtlenv/storage/blocksstable/test_merge_cg_scanner.cpp b/mittest/mtlenv/storage/blocksstable/test_merge_cg_scanner.cpp new file mode 100644 index 0000000000..a8452d16f3 --- /dev/null +++ b/mittest/mtlenv/storage/blocksstable/test_merge_cg_scanner.cpp @@ -0,0 +1,402 @@ +/** + * Copyright (c) 2023 OceanBase + * OceanBase CE is licensed under Mulan PubL v2. + * You can use this software according to the terms and conditions of the Mulan PubL v2. + * You may obtain a copy of Mulan PubL v2 at: + * http://license.coscl.org.cn/MulanPubL-2.0 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PubL v2 for more details. + */ + +#include +#define private public +#define protected public + +#include "lib/random/ob_random.h" +#include "sql/engine/basic/ob_pushdown_filter.h" +#include "storage/tablet/ob_tablet.h" +#include "storage/column_store/ob_cg_prefetcher.h" +#include "storage/column_store/ob_cg_scanner.h" +#include "ob_index_block_data_prepare.h" + +namespace oceanbase +{ +using namespace storage; +using namespace common; +namespace blocksstable +{ +class TestCGScanner : public TestIndexBlockDataPrepare +{ +public: + TestCGScanner(); + virtual ~TestCGScanner(); + static void SetUpTestCase(); + static void TearDownTestCase(); + + virtual void SetUp(); + virtual void TearDown(); + void prepare_cg_query_param(const bool is_reverse_scan, const ObVersionRange &scan_version, const uint32_t cg_idx); + void destroy_cg_query_param(); + void check_data(ObCGRowScanner *cg_scanner, int64_t start, int64_t locate_count, sql::ObDatum *datums, const bool is_reverse); + + void test_border(const bool is_reverse); + void test_random(const bool is_reverse); + + +public: + ObArenaAllocator allocator_; + ObDatumRow start_row_; + ObDatumRow end_row_; + ObTableAccessParam access_param_; +}; + +TestCGScanner::TestCGScanner() + : TestIndexBlockDataPrepare("Test cg sstable row scanner", ObMergeType::MAJOR_MERGE) +{ + is_cg_data_ = true; + is_ddl_merge_data_ = true; + max_row_cnt_ = 150000; + max_partial_row_cnt_ = 78881; + partial_kv_start_idx_ = 3; +} + +TestCGScanner::~TestCGScanner() +{ +} + +void TestCGScanner::SetUpTestCase() +{ + TestIndexBlockDataPrepare::SetUpTestCase(); +} + +void TestCGScanner::TearDownTestCase() +{ + TestIndexBlockDataPrepare::TearDownTestCase(); +} + +void TestCGScanner::prepare_cg_query_param(const bool is_reverse_scan, const ObVersionRange &scan_version, const uint32_t cg_idx) +{ + schema_cols_.set_allocator(&allocator_); + schema_cols_.init(table_schema_.get_column_count()); + ASSERT_EQ(OB_SUCCESS, table_schema_.get_column_ids(schema_cols_)); + access_param_.iter_param_.table_id_ = table_schema_.get_table_id(); + access_param_.iter_param_.tablet_id_ = table_schema_.get_table_id(); + access_param_.iter_param_.is_same_schema_column_ = true; + access_param_.iter_param_.has_virtual_columns_ = false; + access_param_.iter_param_.vectorized_enabled_ = true; + access_param_.iter_param_.pd_storage_flag_.pd_blockscan_ = true; + access_param_.iter_param_.pd_storage_flag_.pd_filter_ = true; + access_param_.iter_param_.pd_storage_flag_.use_iter_pool_ = true; + access_param_.iter_param_.pd_storage_flag_.use_column_store_ = true; + /* + ObSEArray cg_col_descs; + ObTableReadInfo *cg_read_info = nullptr; + ASSERT_EQ(OB_SUCCESS, tablet_handle_.get_obj()->get_cg_col_descs(cg_idx, cg_col_descs)); + ASSERT_EQ(OB_SUCCESS, MTL(ObTenantCGReadInfoMgr *)->get_cg_read_info(cg_col_descs.at(0), + ObTabletID(tablet_id_), + cg_read_info)); + */ + access_param_.iter_param_.read_info_ = cg_read_info_handle_.get_read_info(); + + //jsut for test + ObQueryFlag query_flag(ObQueryFlag::Forward, + true, /*is daily merge scan*/ + true, /*is read multiple macro block*/ + true, /*sys task scan, read one macro block in single io*/ + false /*full row scan flag, obsoleted*/, + false,/*index back*/ + false); /*query_stat*/ + query_flag.set_not_use_row_cache(); + query_flag.set_use_block_cache(); + if (is_reverse_scan) { + query_flag.scan_order_ = ObQueryFlag::ScanOrder::Reverse; + } else { + query_flag.scan_order_ = ObQueryFlag::ScanOrder::Forward; + } + ASSERT_EQ(OB_SUCCESS, context_.init(query_flag, + store_ctx_, + allocator_, + allocator_, + scan_version)); + context_.ls_id_ = ls_id_; + context_.limit_param_ = nullptr; + context_.is_inited_ = true; +} + +void TestCGScanner::destroy_cg_query_param() +{ + access_param_.reset(); + schema_cols_.reset(); + context_.reset(); + read_info_.reset(); +} + +void TestCGScanner::SetUp() +{ + TestIndexBlockDataPrepare::SetUp(); + ASSERT_EQ(OB_SUCCESS, start_row_.init(allocator_, TEST_COLUMN_CNT)); + ASSERT_EQ(OB_SUCCESS, end_row_.init(allocator_, TEST_COLUMN_CNT)); + ObLSID ls_id(ls_id_); + ObTabletID tablet_id(tablet_id_); + ObLSHandle ls_handle; + ObLSService *ls_svr = MTL(ObLSService*); + ASSERT_EQ(OB_SUCCESS, ls_svr->get_ls(ls_id, ls_handle, ObLSGetMod::STORAGE_MOD)); + + ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet(tablet_id, tablet_handle_)); + sstable_.key_.table_type_ = ObITable::TableType::NORMAL_COLUMN_GROUP_SSTABLE; +} + +void TestCGScanner::TearDown() +{ + tablet_handle_.reset(); + TestIndexBlockDataPrepare::TearDown(); +} + +void TestCGScanner::check_data( + ObCGRowScanner *cg_scanner, + int64_t start, + int64_t locate_count, + sql::ObDatum *datums, + const bool is_reverse) +{ + int ret = OB_SUCCESS; + uint64_t count = 0; + int64_t get_count = 0; + int64_t data_count = MIN(row_cnt_ - start, locate_count); + int64_t end = MIN(row_cnt_ - 1, start + locate_count - 1); + int64_t sql_batch_size = 256; + while (OB_SUCC(ret)) { + if (OB_FAIL(cg_scanner->get_next_rows(count, sql_batch_size))) { + if (OB_ITER_END != ret) { + STORAGE_LOG(WARN, "Fail to get next rows", K(ret)); + ASSERT_EQ(OB_ITER_END, ret); + } else { + for (int64_t i = 0; i < count; i++) { + //STORAGE_LOG(INFO, "get next row info", K(get_count), K(i), K(datums[i].get_int())); + if (!is_reverse) { + ASSERT_EQ(start + get_count, datums[i].get_int()) << i << " start " << start << " locate_count " << locate_count; + } else { + ASSERT_EQ(end - get_count, datums[i].get_int()) << i << " start " << start << " locate_count " << locate_count; + } + get_count++; + } + } + } else { + for (int64_t i = 0; i < count; i++) { + //STORAGE_LOG(INFO, "get next row info", K(get_count), K(i), K(datums[i].get_int())); + if (!is_reverse) { + ASSERT_EQ(start + get_count, datums[i].get_int()) << i << " start " << start << " locate_count " << locate_count; + } else { + ASSERT_EQ(end - get_count, datums[i].get_int()) << i << " start " << start << " locate_count " << locate_count; + } + get_count++; + } + } + } +} + +void TestCGScanner::test_random(const bool is_reverse) +{ + ObVersionRange scan_version; + scan_version.base_version_ = 1; + scan_version.multi_version_start_ = 1; + scan_version.snapshot_version_ = INT64_MAX; + // prepare query param + prepare_cg_query_param(is_reverse, scan_version, 0); + sql::ObExecContext exec_ctx(allocator_); + sql::ObEvalCtx eval_ctx(exec_ctx); + sql::ObPushdownExprSpec expr_spec(allocator_); + static int64_t array_cnt = 1024; + eval_ctx.batch_idx_ = 0; + eval_ctx.batch_size_ = 256; + expr_spec.max_batch_size_ = 256; + void *datum_buf = allocator_.alloc((sizeof(sql::ObDatum) + sizeof(int64_t)) * array_cnt * 2); + sql::ObDatum *datums = new (datum_buf) sql::ObDatum[array_cnt]; + eval_ctx.frames_ = (char **)(&datum_buf); + sql::ObPushdownOperator op(eval_ctx, expr_spec); + ObFixedArray out_cols_project; + out_cols_project.set_allocator(&allocator_); + out_cols_project.init(1); + out_cols_project.push_back(0); + sql::ExprFixedArray exprs; + exprs.set_allocator(&allocator_); + void *expr_buf = allocator_.alloc(sizeof(sql::ObExpr)); + ASSERT_NE(nullptr, expr_buf); + sql::ObExpr *expr = reinterpret_cast(expr_buf); + expr->reset(); + expr->res_buf_off_ = sizeof(sql::ObDatum) * array_cnt; + expr->res_buf_len_ = sizeof(int64_t); + char *ptr = (char *)datum_buf + expr->res_buf_off_; + for (int64_t i = 0; i < array_cnt; i++) { + datums[i].ptr_ = ptr; + ptr += expr->res_buf_len_; + } + + exprs.init(1); + exprs.push_back(expr); + access_param_.iter_param_.out_cols_project_ = &out_cols_project; + access_param_.iter_param_.output_exprs_ = &exprs; + access_param_.iter_param_.op_ = &op; + void *buf = allocator_.alloc(sizeof(ObBlockRowStore)); + ASSERT_NE(nullptr, buf); + ObBlockRowStore *block_row_store = new (buf) ObBlockRowStore(context_); + ASSERT_EQ(OB_SUCCESS, block_row_store->init(access_param_)); + context_.block_row_store_ = block_row_store; + + buf = allocator_.alloc(sizeof(ObCGRowScanner)); + ASSERT_NE(nullptr, buf); + ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; + ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); + + int retry_cnt = 15; + while (retry_cnt > 0) { + int64_t start = ObRandom::rand(0, row_cnt_ - 1); + int64_t locate_count = ObRandom::rand(1, row_cnt_); + + STORAGE_LOG(INFO, "start to locate random range", K(retry_cnt), K(start), K(locate_count), K(row_cnt_)); + ASSERT_EQ(OB_SUCCESS, cg_scanner->locate(ObCSRange(start, locate_count))); + check_data(cg_scanner, start, locate_count, datums, is_reverse); + + retry_cnt--; + } + + STORAGE_LOG(INFO, "test random finished"); + + allocator_.free(datum_buf); + datum_buf = nullptr; + expr->reset(); + allocator_.free(expr); + expr = nullptr; + out_cols_project.reset(); + allocator_.free(block_row_store); + block_row_store = nullptr; + cg_scanner->reset(); + allocator_.free(cg_scanner); + cg_scanner = nullptr; + destroy_cg_query_param(); +} + +void TestCGScanner::test_border(const bool is_reverse) +{ + ObVersionRange scan_version; + scan_version.base_version_ = 1; + scan_version.multi_version_start_ = 1; + scan_version.snapshot_version_ = INT64_MAX; + // prepare query param + prepare_cg_query_param(is_reverse, scan_version, 0); + sql::ObExecContext exec_ctx(allocator_); + sql::ObEvalCtx eval_ctx(exec_ctx); + sql::ObPushdownExprSpec expr_spec(allocator_); + static int64_t array_cnt = 1024; + eval_ctx.batch_idx_ = 0; + eval_ctx.batch_size_ = 256; + expr_spec.max_batch_size_ = 256; + void *datum_buf = allocator_.alloc((sizeof(sql::ObDatum) + sizeof(int64_t)) * array_cnt * 2); + sql::ObDatum *datums = new (datum_buf) sql::ObDatum[array_cnt]; + eval_ctx.frames_ = (char **)(&datum_buf); + sql::ObPushdownOperator op(eval_ctx, expr_spec); + ObFixedArray out_cols_project; + out_cols_project.set_allocator(&allocator_); + out_cols_project.init(1); + out_cols_project.push_back(0); + sql::ExprFixedArray exprs; + exprs.set_allocator(&allocator_); + void *expr_buf = allocator_.alloc(sizeof(sql::ObExpr)); + ASSERT_NE(nullptr, expr_buf); + sql::ObExpr *expr = reinterpret_cast(expr_buf); + expr->reset(); + expr->res_buf_off_ = sizeof(sql::ObDatum) * array_cnt; + expr->res_buf_len_ = sizeof(int64_t); + char *ptr = (char *)datum_buf + expr->res_buf_off_; + for (int64_t i = 0; i < array_cnt; i++) { + datums[i].ptr_ = ptr; + ptr += expr->res_buf_len_; + } + + exprs.init(1); + exprs.push_back(expr); + access_param_.iter_param_.out_cols_project_ = &out_cols_project; + access_param_.iter_param_.output_exprs_ = &exprs; + access_param_.iter_param_.op_ = &op; + void *buf = allocator_.alloc(sizeof(ObBlockRowStore)); + ASSERT_NE(nullptr, buf); + ObBlockRowStore *block_row_store = new (buf) ObBlockRowStore(context_); + ASSERT_EQ(OB_SUCCESS, block_row_store->init(access_param_)); + context_.block_row_store_ = block_row_store; + + buf = allocator_.alloc(sizeof(ObCGRowScanner)); + ASSERT_NE(nullptr, buf); + ObCGRowScanner *cg_scanner = new (buf) ObCGRowScanner(); + ObSSTableWrapper wrapper; + wrapper.sstable_ = &sstable_; + ASSERT_EQ(OB_SUCCESS, cg_scanner->init(access_param_.iter_param_, context_, wrapper)); + + int64_t start = 0; + int64_t locate_count = 0; + ASSERT_EQ(OB_INVALID_ARGUMENT, cg_scanner->locate(ObCSRange(start, locate_count))); + + start = row_cnt_; + locate_count = 1; + ASSERT_EQ(OB_ITER_END, cg_scanner->locate(ObCSRange(start, locate_count))); + + start = row_cnt_ - 99; + locate_count = 100; + ASSERT_EQ(OB_SUCCESS, cg_scanner->locate(ObCSRange(start, locate_count))); + check_data(cg_scanner, start, locate_count, datums, is_reverse); + + start = 0; + locate_count = row_cnt_ + 1; + ASSERT_EQ(OB_SUCCESS, cg_scanner->locate(ObCSRange(start, locate_count))); + check_data(cg_scanner, start, locate_count, datums, is_reverse); + + STORAGE_LOG(INFO, "test border finished"); + + allocator_.free(datum_buf); + datum_buf = nullptr; + expr->reset(); + allocator_.free(expr); + expr = nullptr; + out_cols_project.reset(); + allocator_.free(block_row_store); + block_row_store = nullptr; + cg_scanner->reset(); + allocator_.free(cg_scanner); + cg_scanner = nullptr; + destroy_cg_query_param(); +} + +TEST_F(TestCGScanner, test_border) +{ + test_border(false); +} + +TEST_F(TestCGScanner, test_random) +{ + test_random(false); +} + +TEST_F(TestCGScanner, test_border_reverse) +{ + test_border(true); +} + +TEST_F(TestCGScanner, test_random_reverse) +{ + test_random(true); +} + +} +} + +int main(int argc, char **argv) +{ + system("rm -f test_merge_cg_scanner.log*"); + OB_LOGGER.set_file_name("test_merge_cg_scanner.log", true, true); + oceanbase::common::ObLogger::get_logger().set_log_level("INFO"); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp b/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp index bb9e7bc5b4..b819ac4d3f 100644 --- a/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp +++ b/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp @@ -26,6 +26,7 @@ namespace blocksstable ObDDLIndexBlockRowIterator::ObDDLIndexBlockRowIterator() : is_iter_start_(false), is_iter_finish_(true), + is_normal_cg_(false), btree_iter_(), block_meta_tree_(nullptr), cur_tree_value_(nullptr) @@ -43,6 +44,7 @@ void ObDDLIndexBlockRowIterator::reset() ObIndexBlockRowIterator::reset(); is_iter_finish_ = true; is_iter_start_ = false; + is_normal_cg_ = false; btree_iter_.reset(); block_meta_tree_ = nullptr; cur_tree_value_ = nullptr; @@ -52,6 +54,7 @@ void ObDDLIndexBlockRowIterator::reuse() { is_iter_finish_ = true; is_iter_start_ = false; + is_normal_cg_ = false; btree_iter_.reset(); block_meta_tree_ = nullptr; cur_tree_value_ = nullptr; @@ -73,6 +76,7 @@ int ObDDLIndexBlockRowIterator::init(const ObMicroBlockData &idx_block_data, is_reverse_scan_ = is_reverse_scan; iter_step_ = is_reverse_scan_ ? -1 : 1; datum_utils_ = datum_utils; + is_normal_cg_ = iter_param.is_valid() ? iter_param.sstable_->is_normal_cg_sstable() : false; is_inited_ = true; } return ret; @@ -81,6 +85,7 @@ int ObDDLIndexBlockRowIterator::init(const ObMicroBlockData &idx_block_data, int ObDDLIndexBlockRowIterator::set_iter_param(const ObStorageDatumUtils *datum_utils, bool is_reverse_scan, const storage::ObBlockMetaTree *block_meta_tree, + const bool is_normal_cg, const int64_t iter_step) { int ret = OB_SUCCESS; @@ -92,6 +97,7 @@ int ObDDLIndexBlockRowIterator::set_iter_param(const ObStorageDatumUtils *datum_ is_reverse_scan_ = is_reverse_scan; iter_step_ = iter_step == INT64_MAX ? (is_reverse_scan_ ? -1 : 1) : iter_step; datum_utils_ = datum_utils; + is_normal_cg_ = is_normal_cg; is_inited_ = true; } return ret; @@ -255,7 +261,7 @@ int ObDDLIndexBlockRowIterator::get_next(const ObIndexBlockRowHeader *&idx_row_h cur_tree_value_ = tmp_tree_value; } if (OB_SUCC(ret)) { - row_offset = idx_row_parser_.get_row_offset(); + row_offset = is_normal_cg_ ? 0 : endkey->datums_[0].get_int(); is_scan_left_border = is_reverse_scan_ ? is_end_key : is_start_key; is_scan_right_border = is_reverse_scan_ ? is_start_key : is_end_key; } @@ -427,13 +433,21 @@ int ObDDLSStableAllRangeIterator::init(const ObMicroBlockData &idx_block_data, } if (OB_SUCC(ret)) { - rowkey_read_info_ = &cur_tablet->get_rowkey_read_info(); - iter_param_ = iter_param; + if (iter_param.sstable_->is_normal_cg_sstable()) { + if (OB_FAIL(MTL(ObTenantCGReadInfoMgr *)->get_index_read_info(rowkey_read_info_))) { + LOG_WARN("failed to get index read info from ObTenantCGReadInfoMgr", K(ret)); + } + } else { + rowkey_read_info_ = &cur_tablet->get_rowkey_read_info(); + } + if (OB_SUCC(ret)) { + iter_param_ = iter_param; - is_reverse_scan_ = is_reverse_scan; - iter_step_ = is_reverse_scan_ ? -1 : 1; - datum_utils_ = datum_utils; - is_inited_ = true; + is_reverse_scan_ = is_reverse_scan; + iter_step_ = is_reverse_scan_ ? -1 : 1; + datum_utils_ = datum_utils; + is_inited_ = true; + } } } return ret; diff --git a/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.h b/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.h index ead05e7a0b..b3e96064cf 100644 --- a/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.h +++ b/src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.h @@ -61,11 +61,12 @@ public: virtual void reset() override; virtual void reuse() override; INHERIT_TO_STRING_KV("base iterator:", ObIndexBlockRowIterator, "format:", "ObDDLIndexBlockRowIterator", - K_(is_iter_start), K_(is_iter_finish), KP(cur_tree_value_), KP(block_meta_tree_)); + K_(is_iter_start), K_(is_iter_finish), KP(cur_tree_value_), KP(block_meta_tree_), K(is_normal_cg_)); public: int set_iter_param(const ObStorageDatumUtils *datum_utils, bool is_reverse_scan, const storage::ObBlockMetaTree *block_meta_tree, + const bool is_normal_cg, const int64_t iter_step = INT64_MAX); bool is_valid() { return OB_NOT_NULL(block_meta_tree_); } void set_iter_end() { is_iter_finish_ = true; } @@ -73,6 +74,7 @@ public: private: bool is_iter_start_; bool is_iter_finish_; + bool is_normal_cg_; DDLBtreeIterator btree_iter_; const storage::ObBlockMetaTree *block_meta_tree_; storage::ObBlockMetaTreeValue *cur_tree_value_; diff --git a/src/storage/blocksstable/index_block/ob_sstable_sec_meta_iterator.cpp b/src/storage/blocksstable/index_block/ob_sstable_sec_meta_iterator.cpp index d8e20cedb7..6f4a2a1bd5 100644 --- a/src/storage/blocksstable/index_block/ob_sstable_sec_meta_iterator.cpp +++ b/src/storage/blocksstable/index_block/ob_sstable_sec_meta_iterator.cpp @@ -103,6 +103,7 @@ int ObSSTableSecMetaIterator::open( } if (OB_FAIL(ret) || is_prefetch_end_) { } else if (is_ddl_mem_sstable) { + const bool is_normal_cg = sstable.is_normal_cg_sstable(); const ObMicroBlockData &root_block = sstable_meta_hdl_.get_sstable_meta().get_root_info().get_block_data(); if (ObMicroBlockData::DDL_BLOCK_TREE != root_block.type_ || nullptr == root_block.buf_) { ret = OB_ERR_UNEXPECTED; @@ -110,7 +111,7 @@ int ObSSTableSecMetaIterator::open( } else { block_meta_tree_ = reinterpret_cast(const_cast(root_block.buf_)); const int64_t step = max(1, sample_step); - if (OB_FAIL(ddl_iter_.set_iter_param(const_cast(&rowkey_read_info.get_datum_utils()), is_reverse_scan, block_meta_tree_, step))) { + if (OB_FAIL(ddl_iter_.set_iter_param(const_cast(&rowkey_read_info.get_datum_utils()), is_reverse_scan, block_meta_tree_, is_normal_cg, step))) { LOG_WARN("fail to set ddl iter param", K(ret)); } else if (OB_FAIL(ddl_iter_.locate_range(query_range, true, /*is_left_border*/ diff --git a/src/storage/ddl/ob_tablet_ddl_kv.cpp b/src/storage/ddl/ob_tablet_ddl_kv.cpp index fdf3413c03..678f2a5db0 100644 --- a/src/storage/ddl/ob_tablet_ddl_kv.cpp +++ b/src/storage/ddl/ob_tablet_ddl_kv.cpp @@ -836,10 +836,11 @@ int ObDDLMemtable::init_ddl_index_iterator(const blocksstable::ObStorageDatumUti blocksstable::ObDDLIndexBlockRowIterator *ddl_kv_index_iter) { int ret = OB_SUCCESS; + const bool is_normal_cg = is_normal_cg_sstable(); if (OB_ISNULL(datum_utils) || OB_UNLIKELY(!datum_utils->is_valid()) || OB_ISNULL(ddl_kv_index_iter)) { ret = OB_INVALID_ARGUMENT; LOG_WARN("invalid arguement", K(ret), KP(ddl_kv_index_iter), KPC(datum_utils)); - } else if (OB_FAIL(ddl_kv_index_iter->set_iter_param(datum_utils, is_reverse_scan, &block_meta_tree_))) { + } else if (OB_FAIL(ddl_kv_index_iter->set_iter_param(datum_utils, is_reverse_scan, &block_meta_tree_, is_normal_cg))) { LOG_WARN("fail to set ddl iter param", K(ret)); } return ret;