1123 lines
38 KiB
C++
1123 lines
38 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 <assert.h>
|
|
#include "sql/optimizer/ob_skyline_prunning.h"
|
|
#include "lib/allocator/page_arena.h"
|
|
|
|
using namespace oceanbase::sql;
|
|
using namespace oceanbase::common;
|
|
|
|
namespace test {
|
|
|
|
class ObSkylinePrunningTest : public ::testing::Test {
|
|
public:
|
|
ObSkylinePrunningTest()
|
|
{}
|
|
virtual ~ObSkylinePrunningTest()
|
|
{}
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
static void to_array(const uint64_t* columns, const int64_t column_cnt, ObIArray<uint64_t>& column_ids);
|
|
static void dummy_const_column_info(const int64_t column_cnt, ObIArray<bool>& column_const_info);
|
|
template <typename T>
|
|
static void check(const T* left, const T* right, const ObSkylineDim::CompareStat status,
|
|
const ObSkylineDim::CompareStat reverse_status);
|
|
|
|
void check_index_back_dim(const bool left_index_back, const bool left_has_interesting_order,
|
|
const bool left_can_extract_range, const int64_t left_index_column_cnt, const uint64_t* left,
|
|
const int64_t left_cnt, const bool right_index_back, const bool right_has_interesting_order,
|
|
const bool right_can_extract_range, const int64_t right_index_column_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status);
|
|
static void check_interest_dim(const uint64_t* left, const int64_t left_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status);
|
|
static void check_query_range_dim(const uint64_t* left, const int64_t left_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status);
|
|
ObIndexSkylineDim* create_skyline_index_dim(const bool index_back, const int64_t index_column_cnt,
|
|
const uint64_t* filter_ids, const int64_t filter_cnt, const uint64_t* interest_ids, const int64_t interest_cnt,
|
|
const uint64_t* range_ids, const int64_t range_cnt);
|
|
|
|
protected:
|
|
ObArenaAllocator allocator_;
|
|
};
|
|
|
|
void ObSkylinePrunningTest::SetUp()
|
|
{}
|
|
|
|
void ObSkylinePrunningTest::TearDown()
|
|
{}
|
|
|
|
void ObSkylinePrunningTest::to_array(const uint64_t* columns, const int64_t column_cnt, ObIArray<uint64_t>& column_ids)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
for (int64_t i = 0; i < column_cnt; ++i) {
|
|
ret = column_ids.push_back(columns[i]);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
}
|
|
}
|
|
|
|
void ObSkylinePrunningTest::dummy_const_column_info(const int64_t column_cnt, ObIArray<bool>& column_const_info)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
for (int64_t i = 0; i < column_cnt; i++) {
|
|
ret = column_const_info.push_back(false);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
}
|
|
}
|
|
|
|
ObIndexSkylineDim* ObSkylinePrunningTest::create_skyline_index_dim(const bool index_back,
|
|
const int64_t index_column_cnt, const uint64_t* filter_ids, const int64_t filter_cnt, const uint64_t* interest_ids,
|
|
const int64_t interest_cnt, const uint64_t* range_ids, const int64_t range_cnt)
|
|
{
|
|
ObIndexSkylineDim* t = NULL;
|
|
ObSkylineDimFactory::get_instance().create_skyline_dim<ObIndexSkylineDim>(allocator_, t);
|
|
ObArray<uint64_t> filter_array;
|
|
to_array(filter_ids, filter_cnt, filter_array);
|
|
t->add_index_back_dim(index_back, interest_cnt > 0, range_cnt > 0, index_column_cnt, filter_array, allocator_);
|
|
ObArray<uint64_t> interest_array;
|
|
ObArray<uint64_t> rowkey_array;
|
|
ObArray<bool> const_column_info;
|
|
to_array(interest_ids, interest_cnt, interest_array);
|
|
to_array(range_ids, range_cnt, rowkey_array);
|
|
dummy_const_column_info(interest_cnt, const_column_info);
|
|
t->add_interesting_order_dim(index_back, range_cnt > 0, filter_array, interest_array, const_column_info, allocator_);
|
|
t->add_query_range_dim(rowkey_array, allocator_);
|
|
return t;
|
|
}
|
|
|
|
template <typename T>
|
|
void ObSkylinePrunningTest::check(const T* left, const T* right, const ObSkylineDim::CompareStat status,
|
|
const ObSkylineDim::CompareStat reverse_status)
|
|
{
|
|
ObSkylineDim::CompareStat tmp_status;
|
|
int ret = left->compare(*right, tmp_status);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(status, tmp_status);
|
|
SHARE_SCHEMA_LOG(WARN, "check failed", K(status), K(tmp_status), K(*left), K(*right));
|
|
if (status != tmp_status) {
|
|
SHARE_SCHEMA_LOG(WARN, "check failed", K(status), K(tmp_status), K(*left), K(*right));
|
|
}
|
|
ret = right->compare(*left, tmp_status);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(reverse_status, tmp_status);
|
|
SHARE_SCHEMA_LOG(WARN, "check failed", K(reverse_status), K(tmp_status), K(*left), K(*right));
|
|
if (reverse_status != tmp_status) {
|
|
SHARE_SCHEMA_LOG(WARN, "check failed", K(reverse_status), K(tmp_status), K(*left), K(*right));
|
|
}
|
|
}
|
|
|
|
void ObSkylinePrunningTest::check_index_back_dim(const bool left_index_back, const bool left_has_interesting_order,
|
|
const bool left_can_extract_range, const int64_t left_index_column_cnt, const uint64_t* left,
|
|
const int64_t left_cnt, const bool right_index_back, const bool right_has_interesting_order,
|
|
const bool right_can_extract_range, const int64_t right_index_column_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status)
|
|
{
|
|
ObIndexBackDim left_dim;
|
|
left_dim.set_index_back(left_index_back);
|
|
left_dim.set_interesting_order(left_has_interesting_order);
|
|
left_dim.set_extract_range(left_can_extract_range);
|
|
left_dim.set_index_column_cnt(left_index_column_cnt);
|
|
if (left_cnt > 0) {
|
|
ObArray<uint64_t> left_ids;
|
|
to_array(left, left_cnt, left_ids);
|
|
left_dim.add_filter_column_ids(left_ids);
|
|
}
|
|
|
|
ObIndexBackDim right_dim;
|
|
right_dim.set_index_back(right_index_back);
|
|
right_dim.set_interesting_order(right_has_interesting_order);
|
|
right_dim.set_extract_range(right_can_extract_range);
|
|
right_dim.set_index_column_cnt(right_index_column_cnt);
|
|
if (right_cnt > 0) {
|
|
ObArray<uint64_t> right_ids;
|
|
to_array(right, right_cnt, right_ids);
|
|
right_dim.add_filter_column_ids(right_ids);
|
|
}
|
|
check(&left_dim, &right_dim, status, reverse_status);
|
|
}
|
|
|
|
void ObSkylinePrunningTest::check_interest_dim(const uint64_t* left, const int64_t left_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status)
|
|
{
|
|
ObArray<uint64_t> left_ids;
|
|
ObArray<uint64_t> right_ids;
|
|
ObArray<bool> left_const_column_info;
|
|
ObArray<bool> right_const_column_info;
|
|
to_array(left, left_cnt, left_ids);
|
|
to_array(right, right_cnt, right_ids);
|
|
dummy_const_column_info(left_cnt, left_const_column_info);
|
|
dummy_const_column_info(right_cnt, right_const_column_info);
|
|
|
|
ObInterestOrderDim left_dim;
|
|
if (left_cnt > 0) {
|
|
left_dim.set_intereting_order(true);
|
|
left_dim.add_interest_prefix_ids(left_ids);
|
|
left_dim.add_const_column_info(left_const_column_info);
|
|
} else {
|
|
left_dim.set_intereting_order(false);
|
|
}
|
|
|
|
ObInterestOrderDim right_dim;
|
|
if (right_cnt > 0) {
|
|
right_dim.set_intereting_order(true);
|
|
right_dim.add_interest_prefix_ids(right_ids);
|
|
right_dim.add_const_column_info(right_const_column_info);
|
|
} else {
|
|
right_dim.set_intereting_order(false);
|
|
}
|
|
check(&left_dim, &right_dim, status, reverse_status);
|
|
}
|
|
|
|
void ObSkylinePrunningTest::check_query_range_dim(const uint64_t* left, const int64_t left_cnt, const uint64_t* right,
|
|
const int64_t right_cnt, const ObSkylineDim::CompareStat status, const ObSkylineDim::CompareStat reverse_status)
|
|
{
|
|
ObArray<uint64_t> left_ids;
|
|
ObArray<uint64_t> right_ids;
|
|
to_array(left, left_cnt, left_ids);
|
|
to_array(right, right_cnt, right_ids);
|
|
|
|
ObQueryRangeDim left_dim;
|
|
if (left_cnt > 0) {
|
|
left_dim.add_rowkey_ids(left_ids);
|
|
}
|
|
|
|
ObQueryRangeDim right_dim;
|
|
if (right_cnt > 0) {
|
|
right_dim.add_rowkey_ids(right_ids);
|
|
}
|
|
check(&left_dim, &right_dim, status, reverse_status);
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, basic)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObIndexBackDim* index_dim = NULL;
|
|
ret = ObSkylineDimFactory::get_instance().create_skyline_dim<ObIndexBackDim>(allocator_, index_dim);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
ObQueryRangeDim* range_dim = NULL;
|
|
ret = ObSkylineDimFactory::get_instance().create_skyline_dim<ObQueryRangeDim>(allocator_, range_dim);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
ObInterestOrderDim* interest_dim = NULL;
|
|
ret = ObSkylineDimFactory::get_instance().create_skyline_dim<ObInterestOrderDim>(allocator_, interest_dim);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
|
|
ObIndexSkylineDim* index_skyline_dim = NULL;
|
|
ret = ObSkylineDimFactory::get_instance().create_skyline_dim<ObIndexSkylineDim>(allocator_, index_skyline_dim);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, index_dim)
|
|
{
|
|
{
|
|
ObIndexBackDim dim_true;
|
|
dim_true.set_index_back(true);
|
|
ObIndexBackDim dim_false;
|
|
dim_false.set_index_back(false);
|
|
ObIndexBackDim dim2_true;
|
|
dim2_true.set_index_back(true);
|
|
ObIndexBackDim dim2_false;
|
|
dim2_false.set_index_back(false);
|
|
|
|
// check(&dim_true, &dim_false, ObSkylineDim::RIGHT_DOMINATED, ObSkylineDim::LEFT_DOMINATED);
|
|
check(&dim_true, &dim2_true, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
check(&dim_false, &dim2_false, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns = right_filter_columns
|
|
// left_index_column_cnt = right_index_column_cnt
|
|
// left dominate right
|
|
int64_t left_index_column_cnt = 2;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 2;
|
|
uint64_t right_filter_columns[] = {17, 18};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns = right_filter_columns
|
|
// but left_index_column_cnt < right_index_column_cnt
|
|
// left dominate_right
|
|
int64_t left_index_column_cnt = 2;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 5;
|
|
uint64_t right_filter_columns[] = {17, 18};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns = right_filter_columns
|
|
// but left_index_column_cnt > right_index_column_cnt
|
|
// left dominate_right
|
|
int64_t left_index_column_cnt = 6;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 4;
|
|
uint64_t right_filter_columns[] = {17, 18};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns = right_filter_columns = {}
|
|
// but left_index_column_cnt > right_index_column_cnt
|
|
// left dominate_right
|
|
// right need full index scan, not consider index_column_size
|
|
int64_t left_index_column_cnt = 4;
|
|
uint64_t left_filter_columns[] = {};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 2;
|
|
uint64_t right_filter_columns[] = {};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns > right_filter_columns
|
|
// but left_index_column_cnt = right_index_column_cnt
|
|
// left dominate_right
|
|
// right need full index scan, not consider index_column_size
|
|
int64_t left_index_column_cnt = 2;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 2;
|
|
uint64_t right_filter_columns[] = {17};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns > right_filter_columns
|
|
// but left_index_column_cnt > right_index_column_cnt
|
|
int64_t left_index_column_cnt = 4;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 2;
|
|
uint64_t right_filter_columns[] = {17};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns > right_filter_columns
|
|
// but left_index_column_cnt < right_index_column_cnt
|
|
int64_t left_index_column_cnt = 2;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 5;
|
|
uint64_t right_filter_columns[] = {17};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(false, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns < right_filter_columns
|
|
// not comparable
|
|
int64_t left_index_column_cnt = 5;
|
|
uint64_t left_filter_columns[] = {17, 18, 19};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 6;
|
|
uint64_t right_filter_columns[] = {17, 18};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns < right_filter_columns
|
|
// not comparable
|
|
int64_t left_index_column_cnt = 5;
|
|
uint64_t left_filter_columns[] = {17, 18};
|
|
int64_t left_filter_column_cnt = sizeof(left_filter_columns) / sizeof(uint64_t);
|
|
|
|
int64_t right_index_column_cnt = 6;
|
|
uint64_t right_filter_columns[] = {17, 18, 19};
|
|
int64_t right_filter_column_cnt = sizeof(right_filter_columns) / sizeof(uint64_t);
|
|
check_index_back_dim(true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
left_filter_columns,
|
|
left_filter_column_cnt,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
right_filter_columns,
|
|
right_filter_column_cnt,
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
// left (not index back), right (index back)
|
|
// left_filter_columns < right_filter_columns
|
|
// not comparable
|
|
int64_t left_index_column_cnt = 5;
|
|
|
|
int64_t right_index_column_cnt = 6;
|
|
check_index_back_dim(true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
left_index_column_cnt,
|
|
NULL,
|
|
0,
|
|
true, // index_back
|
|
false, // interesting order
|
|
false, // query range
|
|
right_index_column_cnt,
|
|
NULL,
|
|
0,
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, interest_dim)
|
|
{
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 17, 18};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
NULL,
|
|
0,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 17, 18};
|
|
uint64_t column_ids2[] = {17, 18, 19};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 20, 23, 55};
|
|
uint64_t column_ids2[] = {16, 20, 23, 55};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {25, 22, 16};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {22, 25};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {16};
|
|
check_interest_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
check_interest_dim(NULL, 0, NULL, 0, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, query_range_dim)
|
|
{
|
|
{
|
|
uint64_t column_ids[] = {16, 17, 18};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
NULL,
|
|
0,
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 17, 18};
|
|
uint64_t column_ids2[] = {17, 18, 19};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::UNCOMPARABLE,
|
|
ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 20, 23, 55};
|
|
uint64_t column_ids2[] = {16, 20, 23, 55};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {25, 22, 16};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::EQUAL,
|
|
ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {22, 25};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t column_ids[] = {16, 22, 25};
|
|
uint64_t column_ids2[] = {16};
|
|
check_query_range_dim(column_ids,
|
|
sizeof(column_ids) / sizeof(uint64_t),
|
|
column_ids2,
|
|
sizeof(column_ids2) / sizeof(uint64_t),
|
|
ObSkylineDim::LEFT_DOMINATED,
|
|
ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
check_query_range_dim(NULL, 0, NULL, 0, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, key_prefix_compare)
|
|
{
|
|
{
|
|
uint64_t left[] = {15, 16};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {15, 16, 17, 18, 19};
|
|
bool right_column_const[] = {false, false, false, false, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 17};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {15, 16, 17, 18, 19};
|
|
bool right_column_const[] = {false, false, false, false, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {17};
|
|
bool left_column_const[] = {false};
|
|
uint64_t right[] = {15, 16, 17};
|
|
bool right_column_const[] = {false, false, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 16, 17};
|
|
bool left_column_const[] = {false, false, false};
|
|
uint64_t right[] = {15, 16, 17};
|
|
bool right_column_const[] = {false, false, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 17};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {15, 16, 17};
|
|
bool right_column_const[] = {false, true, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15};
|
|
bool left_column_const[] = {false};
|
|
uint64_t right[] = {15, 16, 17};
|
|
bool right_column_const[] = {false, true, false};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 16};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {15, 16, 17};
|
|
bool right_column_const[] = {false, false, true};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 16};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {17, 15, 16};
|
|
bool right_column_const[] = {true, true, true};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 16};
|
|
bool left_column_const[] = {false, false};
|
|
uint64_t right[] = {15, 17, 18};
|
|
bool right_column_const[] = {true, true, true};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t left[] = {15, 16};
|
|
bool left_column_const[] = {false};
|
|
uint64_t right[] = {15, 16};
|
|
bool right_column_const[] = {true, true, true};
|
|
KeyPrefixComp comp;
|
|
int ret = comp(left,
|
|
left_column_const,
|
|
sizeof(left) / sizeof(uint64_t),
|
|
right,
|
|
right_column_const,
|
|
sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::EQUAL);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, range_subset_compare)
|
|
{
|
|
{
|
|
uint64_t left[] = {16, 18};
|
|
uint64_t right[] = {15, 16, 17, 18, 19};
|
|
RangeSubsetComp comp;
|
|
int ret = comp(left, sizeof(left) / sizeof(uint64_t), right, sizeof(right) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left2[] = {17, 18, 19};
|
|
uint64_t right2[] = {17, 18, 19};
|
|
RangeSubsetComp comp2;
|
|
int ret = comp2(left2, sizeof(left2) / sizeof(uint64_t), right2, sizeof(right2) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp2.get_result(), ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t left2[] = {17, 18, 19};
|
|
uint64_t right2[] = {17, 18, 20};
|
|
RangeSubsetComp comp2;
|
|
int ret = comp2(left2, sizeof(left2) / sizeof(uint64_t), right2, sizeof(right2) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp2.get_result(), ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t left2[] = {20};
|
|
uint64_t right2[] = {17, 18, 20};
|
|
RangeSubsetComp comp2;
|
|
int ret = comp2(left2, sizeof(left2) / sizeof(uint64_t), right2, sizeof(right2) / sizeof(uint64_t));
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(comp2.get_result(), ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, skyline_index_compare)
|
|
{
|
|
{
|
|
uint64_t left_interest_ids[] = {16, 17, 18};
|
|
uint64_t left_query_range_ids[] = {10, 20};
|
|
|
|
uint64_t right_interest_ids[] = {16, 17, 18};
|
|
uint64_t right_query_range_ids[] = {20, 10};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
left_interest_ids,
|
|
sizeof(left_interest_ids) / sizeof(uint64_t),
|
|
left_query_range_ids,
|
|
sizeof(left_query_range_ids) / sizeof(uint64_t));
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
right_interest_ids,
|
|
sizeof(right_interest_ids) / sizeof(uint64_t),
|
|
right_query_range_ids,
|
|
sizeof(right_query_range_ids) / sizeof(uint64_t));
|
|
check(dim1, dim2, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t left_interest_ids[] = {16, 17, 18};
|
|
uint64_t left_query_range_ids[] = {10};
|
|
|
|
uint64_t right_interest_ids[] = {16, 17, 18};
|
|
uint64_t right_query_range_ids[] = {20};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
left_interest_ids,
|
|
sizeof(left_interest_ids) / sizeof(uint64_t),
|
|
left_query_range_ids,
|
|
sizeof(left_query_range_ids) / sizeof(uint64_t));
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
right_interest_ids,
|
|
sizeof(right_interest_ids) / sizeof(uint64_t),
|
|
right_query_range_ids,
|
|
sizeof(right_query_range_ids) / sizeof(uint64_t));
|
|
check(dim1, dim2, ObSkylineDim::UNCOMPARABLE, ObSkylineDim::UNCOMPARABLE);
|
|
}
|
|
|
|
{
|
|
uint64_t left_interest_ids[] = {16, 17, 20};
|
|
uint64_t left_query_range_ids[] = {10, 20, 30};
|
|
|
|
uint64_t right_interest_ids[] = {16, 17, 20};
|
|
uint64_t right_query_range_ids[] = {30};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
left_interest_ids,
|
|
sizeof(left_interest_ids) / sizeof(uint64_t),
|
|
left_query_range_ids,
|
|
sizeof(left_query_range_ids) / sizeof(uint64_t));
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
right_interest_ids,
|
|
sizeof(right_interest_ids) / sizeof(uint64_t),
|
|
right_query_range_ids,
|
|
sizeof(right_query_range_ids) / sizeof(uint64_t));
|
|
check(dim1, dim2, ObSkylineDim::LEFT_DOMINATED, ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(true, 4 /*index_column_cnt*/, NULL, 0, NULL, 0, NULL, 0);
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(true, 4 /*index_column_cnt*/, NULL, 0, NULL, 0, NULL, 0);
|
|
check(dim1, dim2, ObSkylineDim::EQUAL, ObSkylineDim::EQUAL);
|
|
}
|
|
|
|
{
|
|
uint64_t left_interest_ids[] = {16, 17, 20};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
4 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
left_interest_ids,
|
|
sizeof(left_interest_ids) / sizeof(uint64_t),
|
|
NULL,
|
|
0);
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false, 4 /*index_column_cnt*/, NULL, 0, NULL, 0, NULL, 0);
|
|
check(dim1, dim2, ObSkylineDim::LEFT_DOMINATED, ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
|
|
{
|
|
uint64_t left_query_range_ids[] = {20, 10, 11};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
4 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
left_query_range_ids,
|
|
sizeof(left_query_range_ids) / sizeof(uint64_t));
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false, 4 /*index_column_cnt*/, NULL, 0, NULL, 0, NULL, 0);
|
|
check(dim1, dim2, ObSkylineDim::LEFT_DOMINATED, ObSkylineDim::RIGHT_DOMINATED);
|
|
}
|
|
}
|
|
|
|
TEST_F(ObSkylinePrunningTest, has_dominate_index)
|
|
{
|
|
ObSkylineDimRecorder recorder;
|
|
uint64_t interest_ids[] = {16, 17};
|
|
uint64_t range_ids[] = {10, 20};
|
|
ObIndexSkylineDim* dim = create_skyline_index_dim(false,
|
|
4 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
interest_ids,
|
|
sizeof(interest_ids) / sizeof(uint64_t),
|
|
range_ids,
|
|
sizeof(range_ids) / sizeof(uint64_t));
|
|
|
|
uint64_t interest_ids_1[] = {16, 18};
|
|
uint64_t range_ids_1[] = {20, 10};
|
|
ObIndexSkylineDim* dim1 = create_skyline_index_dim(false,
|
|
2 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
interest_ids_1,
|
|
sizeof(interest_ids_1) / sizeof(uint64_t),
|
|
range_ids_1,
|
|
sizeof(range_ids_1) / sizeof(uint64_t));
|
|
|
|
uint64_t interest_ids_2[] = {16};
|
|
uint64_t range_ids_2[] = {10};
|
|
ObIndexSkylineDim* dim2 = create_skyline_index_dim(false,
|
|
1 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
interest_ids_2,
|
|
sizeof(interest_ids_2) / sizeof(uint64_t),
|
|
range_ids_2,
|
|
sizeof(range_ids_2) / sizeof(uint64_t));
|
|
|
|
bool has_add = false;
|
|
ObArray<int64_t> remove_idxs;
|
|
bool need_add = true;
|
|
int ret = recorder.has_dominate_dim(*dim, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, true);
|
|
ASSERT_EQ(remove_idxs.count(), 0);
|
|
ret = recorder.add_index_dim(*dim, has_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(true, has_add);
|
|
|
|
remove_idxs.reset();
|
|
ret = recorder.has_dominate_dim(*dim1, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, true);
|
|
ASSERT_EQ(remove_idxs.count(), 0);
|
|
ret = recorder.add_index_dim(*dim1, has_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(true, has_add);
|
|
ASSERT_EQ(recorder.get_dim_count(), 2);
|
|
|
|
remove_idxs.reset();
|
|
ret = recorder.has_dominate_dim(*dim2, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, false);
|
|
ASSERT_EQ(remove_idxs.count(), 0);
|
|
ret = recorder.add_index_dim(*dim2, has_add);
|
|
ASSERT_EQ(false, has_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(recorder.get_dim_count(), 2);
|
|
|
|
uint64_t interest_ids_3[] = {16, 17, 18};
|
|
uint64_t range_ids_3[] = {10, 20, 30};
|
|
ObIndexSkylineDim* dim3 = create_skyline_index_dim(false,
|
|
3 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
interest_ids_3,
|
|
sizeof(interest_ids_3) / sizeof(uint64_t),
|
|
range_ids_3,
|
|
sizeof(range_ids_3) / sizeof(uint64_t));
|
|
|
|
ret = recorder.has_dominate_dim(*dim3, remove_idxs, need_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(need_add, true);
|
|
ASSERT_EQ(remove_idxs.count(), 1);
|
|
ASSERT_EQ(remove_idxs.at(0), 0);
|
|
|
|
ret = recorder.add_index_dim(*dim3, has_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(true, has_add);
|
|
ASSERT_EQ(recorder.get_dim_count(), 2);
|
|
|
|
// unprunning index
|
|
ObIndexSkylineDim* dim2_unprunning = create_skyline_index_dim(false,
|
|
1 /*index_column_cnt*/,
|
|
NULL,
|
|
0,
|
|
interest_ids_2,
|
|
sizeof(interest_ids_2) / sizeof(uint64_t),
|
|
range_ids_2,
|
|
sizeof(range_ids_2) / sizeof(uint64_t));
|
|
dim2_unprunning->set_can_prunning(false); // can't prunning
|
|
remove_idxs.reset();
|
|
ret = recorder.has_dominate_dim(*dim2_unprunning, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, false);
|
|
ASSERT_EQ(remove_idxs.count(), 0);
|
|
ret = recorder.add_index_dim(*dim2_unprunning, has_add);
|
|
ASSERT_EQ(true, has_add);
|
|
ASSERT_EQ(ret, OB_SUCCESS);
|
|
ASSERT_EQ(recorder.get_dim_count(), 3);
|
|
|
|
// check, can add again
|
|
uint64_t interest_ids_4[] = {20, 21, 22};
|
|
uint64_t range_ids_4[] = {19, 20};
|
|
ObIndexSkylineDim* dim4 = create_skyline_index_dim(false,
|
|
4 /*index_column_cnt*/,
|
|
NULL,
|
|
0, // index back
|
|
interest_ids_4,
|
|
sizeof(interest_ids_4) / sizeof(uint64_t),
|
|
range_ids_4,
|
|
sizeof(range_ids_4) / sizeof(uint64_t));
|
|
remove_idxs.reset();
|
|
need_add = false;
|
|
has_add = false;
|
|
dim4->set_can_prunning(false); // can't prunning
|
|
recorder.has_dominate_dim(*dim4, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, true);
|
|
ret = recorder.add_index_dim(*dim4, has_add);
|
|
ASSERT_EQ(has_add, true);
|
|
|
|
uint64_t interest_ids_5[] = {20, 21};
|
|
uint64_t range_ids_5[] = {19};
|
|
ObIndexSkylineDim* dim5 = create_skyline_index_dim(false, // index back
|
|
2 /*index_column_cnt*/,
|
|
NULL,
|
|
0, // filter_ids,
|
|
interest_ids_5,
|
|
sizeof(interest_ids_5) / sizeof(uint64_t),
|
|
range_ids_5,
|
|
sizeof(range_ids_5) / sizeof(uint64_t));
|
|
remove_idxs.reset();
|
|
need_add = false;
|
|
recorder.has_dominate_dim(*dim5, remove_idxs, need_add);
|
|
ASSERT_EQ(need_add, true);
|
|
}
|
|
|
|
} // namespace test
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
system("rm -rf test_skyline_prunning.log");
|
|
if (argc >= 2) {
|
|
if (strcmp("DEBUG", argv[1]) == 0 || strcmp("WARN", argv[1]) == 0)
|
|
OB_LOGGER.set_log_level(argv[1]);
|
|
}
|
|
OB_LOGGER.set_file_name("test_skyline_prunning.log", true);
|
|
oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|