772 lines
25 KiB
C++
772 lines
25 KiB
C++
/**
|
|
* Copyright (c) 2021 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>
|
|
#include "ob_sstable_test.h"
|
|
|
|
namespace oceanbase {
|
|
using namespace blocksstable;
|
|
using namespace common;
|
|
using namespace storage;
|
|
using namespace share::schema;
|
|
|
|
namespace unittest {
|
|
class TestSSTableSingleScanner : public ObSSTableTest {
|
|
public:
|
|
TestSSTableSingleScanner();
|
|
void test_border(const bool is_reverse_scan, const int64_t limit);
|
|
void test_normal(const bool is_reverse_scan, const int64_t limit);
|
|
void test_multi_block_read_continue_io(const bool is_reverse_scan, const int64_t limit);
|
|
void test_multi_block_read_discrete_io(const bool is_reverse_scan, const int64_t limit);
|
|
void generate_range(const int64_t start, const int64_t end, ObStoreRange& range);
|
|
void test_one_case(const ObStoreRange& range, const int64_t start, const int64_t end, const bool is_reverse_scan,
|
|
const int64_t hit_mode);
|
|
void test_skip_range(const bool is_reverse_scan, const common::ObIArray<SkipInfo>& skip_infos);
|
|
virtual ~TestSSTableSingleScanner();
|
|
|
|
private:
|
|
ObStoreRow start_row_;
|
|
ObStoreRow end_row_;
|
|
ObObj start_cells_[TEST_COLUMN_CNT];
|
|
ObObj end_cells_[TEST_COLUMN_CNT];
|
|
};
|
|
|
|
TestSSTableSingleScanner::TestSSTableSingleScanner() : ObSSTableTest("single_scan_sstable")
|
|
{}
|
|
|
|
TestSSTableSingleScanner::~TestSSTableSingleScanner()
|
|
{}
|
|
|
|
void TestSSTableSingleScanner::generate_range(const int64_t start, const int64_t end, ObStoreRange& range)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
start_row_.row_val_.assign(start_cells_, TEST_COLUMN_CNT);
|
|
end_row_.row_val_.assign(end_cells_, TEST_COLUMN_CNT);
|
|
ret = row_generate_.get_next_row(start, start_row_);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ret = row_generate_.get_next_row(end, end_row_);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
range.get_start_key().assign(start_cells_, TEST_ROWKEY_COLUMN_CNT);
|
|
range.get_end_key().assign(end_cells_, TEST_ROWKEY_COLUMN_CNT);
|
|
range.get_border_flag().set_inclusive_start();
|
|
range.get_border_flag().set_inclusive_end();
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_one_case(const ObStoreRange& range, const int64_t start, const int64_t end,
|
|
const bool is_reverse_scan, const int64_t hit_mode)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRowIterator* scanner = NULL;
|
|
ObStoreRow row;
|
|
ObObj cells[TEST_COLUMN_CNT];
|
|
row.row_val_.assign(cells, TEST_COLUMN_CNT);
|
|
const ObStoreRow* prow = NULL;
|
|
ObExtStoreRange ext_range;
|
|
|
|
if (HIT_PART == hit_mode) {
|
|
const int64_t part_start = start + (end - start) / 3;
|
|
const int64_t part_end = end - (end - start) / 3;
|
|
ObStoreRange part_range;
|
|
ObStoreRow start_row;
|
|
ObStoreRow end_row;
|
|
ObObj start_cells[TEST_COLUMN_CNT];
|
|
ObObj end_cells[TEST_COLUMN_CNT];
|
|
start_row.row_val_.assign(start_cells, TEST_COLUMN_CNT);
|
|
end_row.row_val_.assign(end_cells, TEST_COLUMN_CNT);
|
|
ret = row_generate_.get_next_row(part_start, start_row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ret = row_generate_.get_next_row(part_end, end_row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
part_range.get_start_key().assign(start_cells, TEST_ROWKEY_COLUMN_CNT);
|
|
part_range.get_end_key().assign(end_cells, TEST_ROWKEY_COLUMN_CNT);
|
|
part_range.get_border_flag().set_inclusive_start();
|
|
part_range.get_border_flag().set_inclusive_end();
|
|
convert_range(part_range, ext_range, allocator_);
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
for (int64_t i = part_start; i <= part_end; ++i) {
|
|
if (i < row_cnt_) {
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_SUCCESS, ret) << "i: " << i << " part_start: " << part_start << " part_end: " << part_end
|
|
<< " prow: " << prow;
|
|
}
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
}
|
|
if (nullptr != scanner) {
|
|
scanner->~ObStoreRowIterator();
|
|
scanner = nullptr;
|
|
}
|
|
|
|
convert_range(range, ext_range, allocator_);
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
for (int64_t i = start; i <= end; ++i) {
|
|
int64_t index = 0;
|
|
if (is_reverse_scan) {
|
|
ret = row_generate_.get_next_row(end - i + start, row);
|
|
index = end - i + start;
|
|
} else {
|
|
ret = row_generate_.get_next_row(i, row);
|
|
index = i;
|
|
}
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
if (index < row_cnt_) {
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_SUCCESS, ret) << "index: " << index << " start: " << start << " end: " << end << " prow: " << prow;
|
|
ASSERT_TRUE(row.row_val_ == prow->row_val_);
|
|
}
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
if (nullptr != scanner) {
|
|
scanner->~ObStoreRowIterator();
|
|
scanner = nullptr;
|
|
}
|
|
|
|
if (HIT_ALL == hit_mode) {
|
|
int64_t index = 0;
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
for (int64_t i = start; i <= end; ++i) {
|
|
if (is_reverse_scan) {
|
|
ret = row_generate_.get_next_row(end - i + start, row);
|
|
index = end - i + start;
|
|
} else {
|
|
ret = row_generate_.get_next_row(i, row);
|
|
index = i;
|
|
}
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
if (index < row_cnt_) {
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_TRUE(row.row_val_ == prow->row_val_);
|
|
}
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
}
|
|
if (nullptr != scanner) {
|
|
scanner->~ObStoreRowIterator();
|
|
scanner = nullptr;
|
|
}
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_skip_range(const bool is_reverse_scan, const common::ObIArray<SkipInfo>& skip_infos)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRowIterator* scanner = NULL;
|
|
ObStoreRange range;
|
|
ObStoreRow row;
|
|
ObStoreRow gap_row;
|
|
ObStoreRowkey gap_rowkey;
|
|
ObObj cells[TEST_COLUMN_CNT];
|
|
row.row_val_.assign(cells, TEST_COLUMN_CNT);
|
|
ObObj gap_key_cells[TEST_COLUMN_CNT];
|
|
gap_row.row_val_.assign(gap_key_cells, TEST_COLUMN_CNT);
|
|
ObExtStoreRange ext_range;
|
|
const ObStoreRow* prow = NULL;
|
|
int64_t step = is_reverse_scan ? -1 : 1;
|
|
int64_t start = is_reverse_scan ? row_cnt_ - 1 : 0;
|
|
int64_t end = is_reverse_scan ? 0 : row_cnt_ - 1;
|
|
|
|
// prepare query param
|
|
const int64_t limit = -1;
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
// test whole range
|
|
range.set_whole_range();
|
|
convert_range(range, ext_range, allocator_);
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
STORAGE_LOG(INFO, "test_skip_range", K(is_reverse_scan), K(skip_infos));
|
|
for (int64_t i = start; compare(is_reverse_scan, i, end); i += step) {
|
|
|
|
ret = row_generate_.get_next_row(i, row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
OB_LOGGER.set_log_level("DEBUG");
|
|
ret = scanner->get_next_row(prow);
|
|
OB_LOGGER.set_log_level("INFO");
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
STORAGE_LOG(INFO, "get_next_row", K(row), K(*prow));
|
|
ASSERT_TRUE(row.row_val_ == prow->row_val_) << i << "\n";
|
|
int64_t j = 0;
|
|
for (j = 0; OB_SUCC(ret) && j < skip_infos.count(); ++j) {
|
|
if (skip_infos.at(j).start_key_ == i) {
|
|
i = skip_infos.at(j).gap_key_ - step;
|
|
break;
|
|
}
|
|
}
|
|
if (j != skip_infos.count()) {
|
|
ret = row_generate_.get_next_row(skip_infos.at(j).gap_key_, gap_row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
gap_rowkey.assign(gap_key_cells, TEST_ROWKEY_COLUMN_CNT);
|
|
OB_LOGGER.set_log_level("DEBUG");
|
|
ret = scanner->skip_range(0, &gap_rowkey, true);
|
|
OB_LOGGER.set_log_level("INFO");
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
STORAGE_LOG(INFO, "skip range to", K(gap_rowkey));
|
|
}
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
if (nullptr != scanner) {
|
|
scanner->~ObStoreRowIterator();
|
|
scanner = nullptr;
|
|
}
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_border(const bool is_reverse_scan, const int64_t limit)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRowIterator* scanner = NULL;
|
|
ObStoreRange range;
|
|
ObStoreRow row;
|
|
ObObj cells[TEST_COLUMN_CNT];
|
|
row.row_val_.assign(cells, TEST_COLUMN_CNT);
|
|
ObExtStoreRange ext_range;
|
|
|
|
// prepare query param
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
// full table scan
|
|
range.set_whole_range();
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, 0, row_cnt_ - 1, is_reverse_scan, i);
|
|
}
|
|
|
|
// the first row of sstable
|
|
generate_range(0, 0, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, 0, 0, is_reverse_scan, i);
|
|
}
|
|
|
|
// the last row of sstable
|
|
generate_range(row_cnt_ - 1, row_cnt_ - 1, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, row_cnt_ - 1, row_cnt_ - 1, is_reverse_scan, i);
|
|
}
|
|
|
|
// not exist
|
|
generate_range(row_cnt_, row_cnt_, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, row_cnt_, row_cnt_, is_reverse_scan, i);
|
|
}
|
|
|
|
// invalid invoke when not inited
|
|
ObSSTable sstable;
|
|
convert_range(range, ext_range, allocator_);
|
|
ret = sstable.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_NE(OB_SUCCESS, ret);
|
|
destroy_query_param();
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_normal(const bool is_reverse_scan, const int64_t limit)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRange range;
|
|
ObRandom random;
|
|
const int64_t random_start = random.get(0, 10000000) % row_cnt_;
|
|
const int64_t random_end = random.get(0, 100000000) % row_cnt_;
|
|
const int64_t start = std::min(random_start, random_end);
|
|
const int64_t end = std::max(random_start, random_end);
|
|
|
|
// prepare query param
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
// multiple rows exist
|
|
generate_range(start, end, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, start, end, is_reverse_scan, i);
|
|
}
|
|
|
|
// multiple rows, partial exist
|
|
generate_range(start, row_cnt_ + 10, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, start, row_cnt_ + 10, is_reverse_scan, i);
|
|
}
|
|
|
|
// single row exist
|
|
generate_range(row_cnt_ / 2, row_cnt_ / 2, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, row_cnt_ / 2, row_cnt_ / 2, is_reverse_scan, i);
|
|
}
|
|
|
|
// not exist
|
|
generate_range(row_cnt_ + 10, row_cnt_ + 20, range);
|
|
for (int64_t i = HIT_ALL; i < HIT_MAX; ++i) {
|
|
test_one_case(range, row_cnt_ + 10, row_cnt_ + 20, is_reverse_scan, i);
|
|
}
|
|
destroy_query_param();
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_multi_block_read_continue_io(const bool is_reverse_scan, const int64_t limit)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRange range;
|
|
|
|
// prepare query param
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
// size < multiblock_read_size
|
|
GCONF.multiblock_read_size = 10 * 1024;
|
|
destroy_all_cache();
|
|
generate_range(0, 10, range);
|
|
test_one_case(range, 0, 10, is_reverse_scan, HIT_NONE);
|
|
|
|
// size > multiblock_read_size
|
|
destroy_all_cache();
|
|
generate_range(0, 100, range);
|
|
test_one_case(range, 0, 100, is_reverse_scan, HIT_NONE);
|
|
destroy_query_param();
|
|
}
|
|
|
|
void TestSSTableSingleScanner::test_multi_block_read_discrete_io(const bool is_reverse_scan, const int64_t limit)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRange range;
|
|
|
|
// prepare query param
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
// gap_size < multiblock_read_gap_size
|
|
GCONF.multiblock_read_size = 10 * 1024;
|
|
GCONF.multiblock_read_gap_size = 5 * 1024;
|
|
destroy_all_cache();
|
|
generate_range(10, 25, range);
|
|
test_one_case(range, 10, 25, is_reverse_scan, HIT_NONE);
|
|
generate_range(0, 100, range);
|
|
test_one_case(range, 0, 100, is_reverse_scan, HIT_NONE);
|
|
|
|
// gap_size > multiblock_read_gap_size
|
|
destroy_all_cache();
|
|
generate_range(10, 60, range);
|
|
test_one_case(range, 10, 60, is_reverse_scan, HIT_NONE);
|
|
generate_range(0, 100, range);
|
|
test_one_case(range, 0, 100, is_reverse_scan, HIT_NONE);
|
|
destroy_query_param();
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_border)
|
|
{
|
|
const bool is_reverse_scan = false;
|
|
int64_t limit = -1;
|
|
test_border(is_reverse_scan, limit);
|
|
limit = 1;
|
|
test_border(is_reverse_scan, limit);
|
|
STORAGE_LOG(INFO, "memory usage", K(lib::get_memory_hold()), K(lib::get_memory_limit()));
|
|
ObMallocAllocator::get_instance()->print_tenant_ctx_memory_usage(500);
|
|
ObMallocAllocator::get_instance()->print_tenant_memory_usage(500);
|
|
ObMallocAllocator::get_instance()->print_tenant_memory_usage(1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_border_reverse_scan)
|
|
{
|
|
const bool is_reverse_scan = true;
|
|
int64_t limit = -1;
|
|
test_border(is_reverse_scan, limit);
|
|
limit = 1;
|
|
test_border(is_reverse_scan, limit);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_normal)
|
|
{
|
|
const bool is_reverse_scan = false;
|
|
int64_t limit = -1;
|
|
test_normal(is_reverse_scan, limit);
|
|
limit = 1;
|
|
test_normal(is_reverse_scan, limit);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_normal_reverse_scan)
|
|
{
|
|
const bool is_reverse_scan = true;
|
|
int64_t limit = -1;
|
|
test_normal(is_reverse_scan, limit);
|
|
limit = 1;
|
|
test_normal(is_reverse_scan, limit);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_scan_mix_columns)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRowIterator* scanner = NULL;
|
|
ObStoreRange range;
|
|
ObExtStoreRange ext_range;
|
|
ObTableAccessParam param;
|
|
const ObStoreRow* prow = NULL;
|
|
|
|
// prepare query param
|
|
const bool is_reverse_scan = false;
|
|
const int64_t limit = -1;
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
columns_.reset();
|
|
ret = table_schema_.get_column_ids(columns_);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
int64_t column_ids[5] = {3, 5, 3, 23, 12};
|
|
ObColDesc col_desc;
|
|
const share::schema::ObColumnSchemaV2* column = NULL;
|
|
for (int64_t i = 0; i < (int64_t)(sizeof(column_ids) / sizeof(int64_t)); ++i) {
|
|
if (NULL == (column = table_schema_.get_column_schema(column_ids[i]))) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
STORAGE_LOG(WARN, "cannot find column.", K(i), K(column_ids[i]));
|
|
} else {
|
|
col_desc.col_id_ = column->get_column_id();
|
|
col_desc.col_type_ = column->get_meta_type();
|
|
if (OB_FAIL(columns_.push_back(col_desc))) {
|
|
STORAGE_LOG(WARN, "push to columns failed.", K(ret));
|
|
}
|
|
}
|
|
}
|
|
|
|
param_.out_cols_ = &columns_;
|
|
|
|
// whole range
|
|
range.set_whole_range();
|
|
convert_range(range, ext_range, allocator_);
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
for (int64_t i = 0; i < row_cnt_; ++i) {
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_TRUE(NULL != prow);
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_estimate)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRange range;
|
|
ObExtStoreRange ext_range;
|
|
ObPartitionEst cost_metrics;
|
|
ObStoreRow row;
|
|
|
|
// prepare query param
|
|
const bool is_reverse_scan = false;
|
|
const int64_t limit = -1;
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
range.set_whole_range();
|
|
cost_metrics.reset();
|
|
convert_range(range, ext_range, allocator_);
|
|
ret = sstable_.estimate_scan_row_count(context_.query_flag_, table_key_.table_id_, ext_range, cost_metrics);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_TRUE(cost_metrics.logical_row_count_ > 2900);
|
|
|
|
ObStoreRow start_row;
|
|
ObStoreRow end_row;
|
|
ObObj start_cells[TEST_COLUMN_CNT];
|
|
ObObj end_cells[TEST_COLUMN_CNT];
|
|
start_row.row_val_.assign(start_cells, TEST_COLUMN_CNT);
|
|
end_row.row_val_.assign(end_cells, TEST_COLUMN_CNT);
|
|
ret = row_generate_.get_next_row(0, start_row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ret = row_generate_.get_next_row(2, end_row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
range.get_start_key().assign(start_cells, TEST_ROWKEY_COLUMN_CNT);
|
|
range.get_end_key().assign(end_cells, TEST_ROWKEY_COLUMN_CNT);
|
|
range.get_border_flag().set_inclusive_start();
|
|
range.get_border_flag().set_inclusive_end();
|
|
convert_range(range, ext_range, allocator_);
|
|
cost_metrics.logical_row_count_ = 0;
|
|
ret = sstable_.estimate_scan_row_count(context_.query_flag_, table_key_.table_id_, ext_range, cost_metrics);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_EQ(3, cost_metrics.logical_row_count_);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_daily_merge)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObStoreRowIterator* scanner = NULL;
|
|
ObArray<ObExtStoreRange> ranges;
|
|
ObStoreRange range;
|
|
ObStoreRow row;
|
|
ObObj cells[TEST_COLUMN_CNT];
|
|
row.row_val_.assign(cells, TEST_COLUMN_CNT);
|
|
ObExtStoreRange ext_range;
|
|
const ObStoreRow* prow = NULL;
|
|
|
|
// prepare query param
|
|
const bool is_reverse_scan = false;
|
|
const int64_t limit = -1;
|
|
ret = prepare_query_param(is_reverse_scan, limit);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
context_.query_flag_.daily_merge_ = 1;
|
|
context_.query_flag_.whole_macro_scan_ = 1;
|
|
|
|
// test whole range
|
|
range.set_whole_range();
|
|
convert_range(range, ext_range, allocator_);
|
|
ranges.push_back(ext_range);
|
|
ret = sstable_.scan(param_, context_, ext_range, scanner);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
for (int64_t i = 0; i < row_cnt_; ++i) {
|
|
ret = row_generate_.get_next_row(i, row);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_TRUE(row.row_val_ == prow->row_val_);
|
|
}
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
ret = scanner->get_next_row(prow);
|
|
ASSERT_EQ(OB_ITER_END, ret);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_single_range)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = row_cnt_ / 4;
|
|
info.gap_key_ = row_cnt_ / 2;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(false, skip_info_array);
|
|
STORAGE_LOG(INFO, "memory usage", K(lib::get_memory_hold()), K(lib::get_memory_limit()));
|
|
ObMallocAllocator::get_instance()->print_tenant_ctx_memory_usage(500);
|
|
ObMallocAllocator::get_instance()->print_tenant_memory_usage(500);
|
|
ObMallocAllocator::get_instance()->print_tenant_memory_usage(1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_single_range_reverse_scan)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = row_cnt_ / 2;
|
|
info.gap_key_ = row_cnt_ / 4;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_multiple_ranges)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = 10;
|
|
info.gap_key_ = 20;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 200;
|
|
info.gap_key_ = 205;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 1000;
|
|
info.gap_key_ = row_cnt_ / 2;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = row_cnt_ / 3 * 2;
|
|
info.gap_key_ = row_cnt_ / 4 * 3;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(false, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_multiple_ranges_reverse_scan)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = row_cnt_ / 4 * 3;
|
|
info.gap_key_ = row_cnt_ / 3 * 2;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = row_cnt_ / 2;
|
|
info.gap_key_ = 1000;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 205;
|
|
info.gap_key_ = 200;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 20;
|
|
info.gap_key_ = 10;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_in_same_micro_range)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = 10;
|
|
info.gap_key_ = 20;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 22;
|
|
info.gap_key_ = 25;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 27;
|
|
info.gap_key_ = 30;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 1900;
|
|
info.gap_key_ = row_cnt_ + 1;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(false, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_in_same_micro_range_reverse_scan)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.gap_key_ = 1900;
|
|
info.start_key_ = row_cnt_ - 1;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.gap_key_ = 27;
|
|
info.start_key_ = 30;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.gap_key_ = 22;
|
|
info.start_key_ = 25;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.gap_key_ = 10;
|
|
info.start_key_ = 20;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_random_range)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t skip_range_cnt = 10;
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
ObRandom random;
|
|
int64_t last_gap_key = 0;
|
|
for (int64_t i = 0; OB_SUCC(ret) && i < skip_range_cnt && last_gap_key <= row_cnt_ - 1; ++i) {
|
|
info.start_key_ = random.get(last_gap_key, row_cnt_ - 1);
|
|
info.gap_key_ = random.get(info.start_key_ + 1, row_cnt_ - 1);
|
|
last_gap_key = info.gap_key_;
|
|
if (info.start_key_ >= row_cnt_ - 1 && info.start_key_ != info.gap_key_) {
|
|
ret = skip_info_array.push_back(info);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
}
|
|
}
|
|
test_skip_range(false, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_random_range_reverse_scan)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const int64_t skip_range_cnt = 10;
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
ObRandom random;
|
|
int64_t last_gap_key = row_cnt_ - 1;
|
|
for (int64_t i = 0; (OB_SUCC(ret) && i < skip_range_cnt) && last_gap_key > 0; ++i) {
|
|
info.start_key_ = random.get(0, last_gap_key);
|
|
info.gap_key_ = random.get(0, info.start_key_ - 1);
|
|
last_gap_key = info.gap_key_;
|
|
if (last_gap_key >= 0 && info.start_key_ != info.gap_key_) {
|
|
ret = skip_info_array.push_back(info);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
}
|
|
}
|
|
STORAGE_LOG(INFO, "test skip random range reverse scan", K(skip_info_array));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_random_range_reverse_scan_bug)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = 1390;
|
|
info.gap_key_ = 346;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 229;
|
|
info.gap_key_ = 34;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 3;
|
|
info.gap_key_ = 0;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_skip_random_range_reverse_scan_bug2)
|
|
{
|
|
ObArray<SkipInfo> skip_info_array;
|
|
SkipInfo info;
|
|
info.start_key_ = 1844;
|
|
info.gap_key_ = 653;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 351;
|
|
info.gap_key_ = 247;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
info.start_key_ = 212;
|
|
info.gap_key_ = 1;
|
|
ASSERT_EQ(OB_SUCCESS, skip_info_array.push_back(info));
|
|
test_skip_range(true, skip_info_array);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_continue_io)
|
|
{
|
|
test_multi_block_read_continue_io(false, -1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_continue_io_reverse_scan)
|
|
{
|
|
test_multi_block_read_continue_io(true, -1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_continue_io_limit)
|
|
{
|
|
test_multi_block_read_continue_io(false, 1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_continue_io_limit_reverse_scan)
|
|
{
|
|
test_multi_block_read_continue_io(true, 1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_read_discrete_io)
|
|
{
|
|
test_multi_block_read_discrete_io(false, -1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_read_discrete_io_reverse_scan)
|
|
{
|
|
test_multi_block_read_discrete_io(true, -1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_read_discrete_io_limit)
|
|
{
|
|
test_multi_block_read_discrete_io(false, 1);
|
|
}
|
|
|
|
TEST_F(TestSSTableSingleScanner, test_multi_block_read_discrete_io_limit_reverse_scan)
|
|
{
|
|
test_multi_block_read_discrete_io(true, 1);
|
|
}
|
|
|
|
} // end namespace unittest
|
|
} // end namespace oceanbase
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
system("rm -f test_sstable_single_scan.log*");
|
|
OB_LOGGER.set_file_name("test_sstable_single_scan.log");
|
|
OB_LOGGER.set_log_level("INFO");
|
|
CLOG_LOG(INFO, "begin unittest: test_sstable_single_scan");
|
|
oceanbase::lib::set_memory_limit(30L * 1024 * 1024 * 1024);
|
|
oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
|
|
testing::InitGoogleTest(&argc, argv);
|
|
STORAGE_LOG(INFO, "sizeof KVCacheInst", K(sizeof(ObKVCacheInst)));
|
|
STORAGE_LOG(INFO, "sizeof KVCacheInfo", K(sizeof(ObKVCacheInfo)));
|
|
return RUN_ALL_TESTS();
|
|
}
|