356 lines
11 KiB
C++
356 lines
11 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 "sql/resolver/expr/ob_raw_expr.h"
|
|
#include "lib/container/ob_bit_set.h"
|
|
#include <cstring>
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::sql;
|
|
using namespace oceanbase::lib;
|
|
using namespace oceanbase;
|
|
|
|
class TestSqlBitSet : public ::testing::Test {
|
|
public:
|
|
TestSqlBitSet();
|
|
virtual ~TestSqlBitSet();
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(TestSqlBitSet);
|
|
};
|
|
|
|
TEST_F(TestSqlBitSet, baisc_interfaces)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_TRUE(0 == bs.bitset_word_count());
|
|
ASSERT_TRUE(bs.is_empty());
|
|
ASSERT_TRUE(0 == bs.num_members());
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(33));
|
|
ASSERT_TRUE(2 == bs.bitset_word_count());
|
|
ASSERT_TRUE(!bs.is_empty());
|
|
ASSERT_TRUE(bs.has_member(33));
|
|
ASSERT_TRUE(!bs.has_member(32));
|
|
ASSERT_TRUE(1 == bs.num_members());
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, add_and_del_number)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_TRUE(OB_SUCCESS != bs.add_member(-1));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(!bs.has_member(-1));
|
|
ASSERT_TRUE(!bs.has_member(1));
|
|
ASSERT_TRUE(bs.has_member(5));
|
|
ASSERT_TRUE(bs.has_member(50));
|
|
|
|
ASSERT_FALSE(OB_SUCCESS == bs.del_member(-1));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.del_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.del_member(500));
|
|
ASSERT_TRUE(!bs.has_member(1));
|
|
ASSERT_TRUE(!bs.has_member(5));
|
|
ASSERT_TRUE(bs.has_member(50));
|
|
ASSERT_TRUE(2 == bs.bitset_word_count());
|
|
ASSERT_TRUE(64 == bs.bit_count());
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, get_bitset_word)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_EQ(0, bs.get_bitset_word(-1));
|
|
ASSERT_EQ(0, bs.get_bitset_word(1));
|
|
ASSERT_EQ(0, bs.get_bitset_word(2));
|
|
ASSERT_EQ(0, bs.get_bitset_word(3));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(90));
|
|
|
|
ASSERT_EQ(32, bs.get_bitset_word(0));
|
|
ASSERT_EQ(262144, bs.get_bitset_word(1));
|
|
ASSERT_EQ(67108864, bs.get_bitset_word(2));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, add_and_del_members)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
|
|
ObSqlBitSet<16> bs2;
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(15));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(200));
|
|
|
|
bs.del_members(bs2);
|
|
ASSERT_TRUE(bs.has_member(5));
|
|
ASSERT_TRUE(!bs.has_member(50));
|
|
ASSERT_TRUE(!bs.has_member(100));
|
|
ASSERT_TRUE(bs.has_member(111));
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_members(bs2));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(200));
|
|
ASSERT_TRUE(bs.has_member(50));
|
|
ASSERT_TRUE(bs.has_member(100));
|
|
ASSERT_TRUE(bs.has_member(200));
|
|
ASSERT_TRUE(bs.has_member(15));
|
|
|
|
ASSERT_EQ(6, bs.num_members());
|
|
}
|
|
|
|
// TEST_F(TestSqlBitSet, add_and_del_members2)
|
|
// {
|
|
// ObSqlBitSet<16> bs;
|
|
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
|
|
// ObBitSet<16> bs2;
|
|
// ASSERT_TRUE(OB_SUCCESS == bs2.add_member(15));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs2.add_member(50));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs2.add_member(100));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs2.add_member(200));
|
|
|
|
// bs.del_members(bs2);
|
|
// ASSERT_TRUE(bs.has_member(5));
|
|
// ASSERT_TRUE(!bs.has_member(50));
|
|
// ASSERT_TRUE(!bs.has_member(100));
|
|
// ASSERT_TRUE(bs.has_member(111));
|
|
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_members(bs2));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs2.add_member(200));
|
|
// ASSERT_TRUE(bs.has_member(50));
|
|
// ASSERT_TRUE(bs.has_member(100));
|
|
// ASSERT_TRUE(bs.has_member(200));
|
|
// ASSERT_TRUE(bs.has_member(15));
|
|
|
|
// ASSERT_EQ(6, bs.num_members());
|
|
// }
|
|
|
|
TEST_F(TestSqlBitSet, do_mask)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.do_mask(6, 101));
|
|
ASSERT_TRUE(bs.has_member(50));
|
|
ASSERT_TRUE(bs.has_member(100));
|
|
ASSERT_TRUE(!bs.has_member(5));
|
|
ASSERT_TRUE(!bs.has_member(111));
|
|
ASSERT_TRUE(!bs.has_member(121));
|
|
|
|
ObSqlBitSet<16> bs2;
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(32));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(63));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.do_mask(32, 63));
|
|
ASSERT_FALSE(bs2.has_member(5));
|
|
ASSERT_TRUE(bs2.has_member(32));
|
|
ASSERT_TRUE(bs2.has_member(63));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, set_operation)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.do_mask(5, 101));
|
|
|
|
// is_superset && is_subset
|
|
ObSqlBitSet<16> bs1;
|
|
ASSERT_TRUE(bs.is_superset(bs1));
|
|
ASSERT_TRUE(bs1.is_subset(bs));
|
|
ASSERT_FALSE(bs1.is_superset(bs));
|
|
ASSERT_FALSE(bs.is_subset(bs1));
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(5));
|
|
ASSERT_FALSE(bs1.is_superset(bs));
|
|
ASSERT_FALSE(bs.is_subset(bs1));
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(100));
|
|
ASSERT_TRUE(bs.is_superset(bs1));
|
|
ASSERT_TRUE(bs1.is_subset(bs));
|
|
}
|
|
|
|
// TEST_F(TestSqlBitSet, set_operation2)
|
|
// {
|
|
// ObSqlBitSet<16> bs;
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs.do_mask(5,101));
|
|
|
|
// //is_superset && is_subset
|
|
// ObBitSet<16> bs1;
|
|
// ASSERT_TRUE(bs.is_superset(bs1));
|
|
// ASSERT_FALSE(bs.is_subset(bs1));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs1.add_member(5));
|
|
// ASSERT_FALSE(bs.is_subset(bs1));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs1.add_member(50));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs1.add_member(100));
|
|
// ASSERT_TRUE(bs.is_superset(bs1));
|
|
// }
|
|
|
|
TEST_F(TestSqlBitSet, overlap)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ObSqlBitSet<16> bs1;
|
|
ASSERT_FALSE(bs.overlap(bs1));
|
|
ASSERT_FALSE(bs1.overlap(bs));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(51));
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(101));
|
|
ASSERT_FALSE(bs.overlap(bs1));
|
|
ASSERT_FALSE(bs1.overlap(bs));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(101));
|
|
ASSERT_TRUE(bs.overlap(bs1));
|
|
ASSERT_TRUE(bs1.overlap(bs));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, equal)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ObSqlBitSet<16> bs2;
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
|
|
ASSERT_FALSE(bs.equal(bs2));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(50));
|
|
ASSERT_FALSE(bs2.equal(bs));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(5));
|
|
ASSERT_TRUE(bs2.equal(bs));
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(550));
|
|
ASSERT_FALSE(bs.equal(bs2));
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(550));
|
|
ASSERT_TRUE(bs.equal(bs2));
|
|
|
|
// ObBitSet<16> bs3;
|
|
// ASSERT_FALSE(bs.equal(bs3));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs3.add_member(550));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs3.add_member(50));
|
|
// ASSERT_FALSE(bs.equal(bs3));
|
|
// ASSERT_TRUE(OB_SUCCESS == bs3.add_member(5));
|
|
// ASSERT_TRUE(bs.equal(bs3));
|
|
|
|
ASSERT_TRUE(OB_SUCCESS == bs2.add_member(1));
|
|
ObSqlBitSet<16> bs4 = bs2;
|
|
ASSERT_TRUE(bs4 == bs2);
|
|
ASSERT_TRUE(bs4.has_member(5));
|
|
ASSERT_TRUE(bs4.has_member(50));
|
|
ASSERT_TRUE(bs4.has_member(550));
|
|
ASSERT_TRUE(bs4.has_member(1));
|
|
ASSERT_FALSE(bs4.has_member(555));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, to_string)
|
|
{
|
|
ObSqlBitSet<16> bs;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(1));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(550));
|
|
|
|
char buf[32];
|
|
static const int64_t buf_len = 32;
|
|
|
|
int64_t pos = bs.to_string(buf, buf_len);
|
|
ASSERT_TRUE(0 == std::strncmp("[1, 5, 50, 550]", buf, pos));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, number_and_clear)
|
|
{
|
|
ObSqlBitSet<128> bs;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
ASSERT_EQ(4, bs.num_members());
|
|
ObSqlBitSet<> bs1;
|
|
ASSERT_EQ(0, bs1.bitset_word_count());
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(5));
|
|
ASSERT_EQ(1, bs1.bitset_word_count());
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(50));
|
|
ASSERT_EQ(2, bs1.bitset_word_count());
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(100));
|
|
ASSERT_EQ(4, bs1.bitset_word_count());
|
|
ASSERT_TRUE(OB_SUCCESS == bs1.add_member(111));
|
|
ASSERT_EQ(4, bs1.bitset_word_count());
|
|
ASSERT_EQ(4, bs1.num_members());
|
|
ASSERT_EQ(4, bs1.bitset_word_count());
|
|
ASSERT_TRUE(bs1.has_member(5));
|
|
ASSERT_TRUE(bs1.has_member(50));
|
|
ASSERT_TRUE(bs1.has_member(100));
|
|
ASSERT_TRUE(bs1.has_member(111));
|
|
|
|
bs1.reuse();
|
|
ASSERT_EQ(0, bs1.bitset_word_count());
|
|
ASSERT_TRUE(bs1.is_empty());
|
|
|
|
ASSERT_FALSE(bs1.has_member(5));
|
|
ASSERT_FALSE(bs1.has_member(50));
|
|
ASSERT_FALSE(bs1.has_member(100));
|
|
ASSERT_FALSE(bs1.has_member(101));
|
|
}
|
|
|
|
TEST_F(TestSqlBitSet, to_array)
|
|
{
|
|
ObSqlBitSet<128> bs;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(5));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(50));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(100));
|
|
ASSERT_TRUE(OB_SUCCESS == bs.add_member(111));
|
|
ObArray<int64_t> arr;
|
|
ASSERT_TRUE(OB_SUCCESS == bs.to_array(arr));
|
|
ASSERT_EQ(4, arr.count());
|
|
ASSERT_EQ(5, arr.at(0));
|
|
ASSERT_EQ(50, arr.at(1));
|
|
ASSERT_EQ(100, arr.at(2));
|
|
ASSERT_EQ(111, arr.at(3));
|
|
}
|
|
|
|
TestSqlBitSet::TestSqlBitSet()
|
|
{}
|
|
TestSqlBitSet::~TestSqlBitSet()
|
|
{}
|
|
void TestSqlBitSet::SetUp()
|
|
{}
|
|
void TestSqlBitSet::TearDown()
|
|
{}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
int ret = 0;
|
|
ContextParam param;
|
|
param.set_mem_attr(1001, 0, ObCtxIds::WORK_AREA).set_page_size(OB_MALLOC_BIG_BLOCK_SIZE);
|
|
CREATE_WITH_TEMP_CONTEXT(param)
|
|
{
|
|
ret = RUN_ALL_TESTS();
|
|
}
|
|
return ret;
|
|
}
|