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

fix offset from DDLKV && fix wrong read_info

Browse Source
This commit is contained in:
renju96
2024-02-08 12:00:54 +00:00
committed by ob-robot
parent 883414e5c3
commit 2d98a71efa
6 changed files with 482 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h
View File

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

402
mittest/mtlenv/storage/blocksstable/test_merge_cg_scanner.cpp Normal file
View File

@ -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 <gtest/gtest.h>
#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<ObColDesc, 1> 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<int32_t, ObIAllocator> 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<sql::ObExpr *>(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<int32_t, ObIAllocator> 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<sql::ObExpr *>(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();
}

28
src/storage/blocksstable/index_block/ob_ddl_index_block_row_iterator.cpp
View File

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

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

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

3
src/storage/blocksstable/index_block/ob_sstable_sec_meta_iterator.cpp
View File

@ -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<ObBlockMetaTree *>(const_cast<char *>(root_block.buf_));
const int64_t step = max(1, sample_step);
if (OB_FAIL(ddl_iter_.set_iter_param(const_cast<ObStorageDatumUtils *>(&rowkey_read_info.get_datum_utils()), is_reverse_scan, block_meta_tree_, step))) {
if (OB_FAIL(ddl_iter_.set_iter_param(const_cast<ObStorageDatumUtils *>(&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*/

3
src/storage/ddl/ob_tablet_ddl_kv.cpp
View File

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