init push
This commit is contained in:
oceanbase-admin
8
unittest/sql/engine/set/CMakeLists.txt
Normal file
8
unittest/sql/engine/set/CMakeLists.txt
Normal file
@ -0,0 +1,8 @@
|
||||
function(set_unittest case)
|
||||
ob_unittest(${ARGV})
|
||||
target_sources(${case} PRIVATE ../join/ob_join_fake_table.h ../join/ob_join_fake_table.cpp)
|
||||
endfunction()
|
||||
sql_unittest(test_merge_intersect)
|
||||
sql_unittest(test_merge_except)
|
||||
sql_unittest(test_merge_union)
|
||||
ob_unittest(test_hash_set_dump test_hash_set_dump.cpp set_data_generator.h)
|
||||
116
unittest/sql/engine/set/ob_set_test_util.h
Normal file
116
unittest/sql/engine/set/ob_set_test_util.h
Normal file
@ -0,0 +1,116 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define private public
|
||||
#define protected public
|
||||
#ifndef OCEANBASE_UNITTEST_SQL_ENGINE_SET_OB_SET_TEST_UTIL_H_
|
||||
#define OCEANBASE_UNITTEST_SQL_ENGINE_SET_OB_SET_TEST_UTIL_H_
|
||||
#include <gtest/gtest.h>
|
||||
#include "sql/engine/table/ob_fake_table.h"
|
||||
#include "sql/engine/set/ob_merge_set_operator.h"
|
||||
#include "sql/session/ob_sql_session_info.h"
|
||||
#include "sql/ob_sql_define.h"
|
||||
#include "sql/engine/test_engine_util.h"
|
||||
|
||||
class TestSetOperatorFactory {
|
||||
public:
|
||||
TestSetOperatorFactory()
|
||||
{}
|
||||
~TestSetOperatorFactory()
|
||||
{}
|
||||
|
||||
static void init(
|
||||
ObExecContext& ctx, ObMergeSetOperator* set_operator, int64_t col_count, bool distinct, bool set_direction)
|
||||
{
|
||||
ASSERT_FALSE(NULL == set_operator);
|
||||
set_operator->reset();
|
||||
set_operator->reuse();
|
||||
fake_table1_.reset();
|
||||
fake_table1_.reuse();
|
||||
fake_table2_.reset();
|
||||
fake_table2_.reuse();
|
||||
result_table_.reset();
|
||||
result_table_.reuse();
|
||||
|
||||
set_operator->init(col_count);
|
||||
int32_t projector[3] = {1, 2, 3};
|
||||
fake_table1_.set_column_count(col_count);
|
||||
fake_table2_.set_column_count(col_count);
|
||||
result_table_.set_column_count(col_count);
|
||||
set_operator->set_column_count(col_count);
|
||||
fake_table1_.set_projector(projector, col_count);
|
||||
fake_table2_.set_projector(projector, col_count);
|
||||
result_table_.set_projector(projector, col_count);
|
||||
set_operator->set_projector(projector, col_count);
|
||||
for (int64_t i = 0; i < col_count; ++i) {
|
||||
ASSERT_EQ(OB_SUCCESS,
|
||||
set_operator->add_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset())));
|
||||
if (set_direction && (i % 2)) {
|
||||
ASSERT_EQ(OB_SUCCESS, set_operator->add_set_direction(oceanbase::sql::NULLS_LAST_DESC));
|
||||
} else {
|
||||
ASSERT_EQ(OB_SUCCESS, set_operator->add_set_direction(oceanbase::sql::NULLS_FIRST_ASC));
|
||||
}
|
||||
}
|
||||
|
||||
fake_table1_.set_id(0);
|
||||
fake_table2_.set_id(1);
|
||||
result_table_.set_id(2);
|
||||
set_operator->set_id(3);
|
||||
|
||||
fake_table1_.set_phy_plan(&physical_plan_);
|
||||
fake_table2_.set_phy_plan(&physical_plan_);
|
||||
result_table_.set_phy_plan(&physical_plan_);
|
||||
set_operator->set_phy_plan(&physical_plan_);
|
||||
|
||||
set_operator->create_child_array(2);
|
||||
set_operator->set_child(0, fake_table1_);
|
||||
set_operator->set_child(1, fake_table2_);
|
||||
set_operator->set_distinct(distinct);
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, ctx.init_phy_op(4));
|
||||
ASSERT_EQ(OB_SUCCESS, ctx.create_physical_plan_ctx());
|
||||
ASSERT_EQ(OB_SUCCESS, create_test_session(ctx));
|
||||
ASSERT_FALSE(NULL == ctx.get_physical_plan_ctx());
|
||||
ASSERT_FALSE(NULL == ctx.get_my_session());
|
||||
ASSERT_EQ(OB_SUCCESS, ctx.get_my_session()->set_time_zone(ObString("+8:00"), true, true));
|
||||
}
|
||||
|
||||
static ObFakeTable& get_fake_table1()
|
||||
{
|
||||
return fake_table1_;
|
||||
}
|
||||
static ObFakeTable& get_fake_table2()
|
||||
{
|
||||
return fake_table2_;
|
||||
}
|
||||
static ObFakeTable& get_result_table()
|
||||
{
|
||||
return result_table_;
|
||||
}
|
||||
static ObPhysicalPlan& get_physical_plan()
|
||||
{
|
||||
return physical_plan_;
|
||||
}
|
||||
|
||||
private:
|
||||
static ObPhysicalPlan physical_plan_;
|
||||
static ObFakeTable fake_table1_;
|
||||
static ObFakeTable fake_table2_;
|
||||
static ObFakeTable result_table_;
|
||||
};
|
||||
|
||||
ObPhysicalPlan TestSetOperatorFactory::physical_plan_;
|
||||
ObFakeTable TestSetOperatorFactory::fake_table1_(TestSetOperatorFactory::get_physical_plan().get_allocator());
|
||||
ObFakeTable TestSetOperatorFactory::fake_table2_(TestSetOperatorFactory::get_physical_plan().get_allocator());
|
||||
ObFakeTable TestSetOperatorFactory::result_table_(TestSetOperatorFactory::get_physical_plan().get_allocator());
|
||||
|
||||
#endif /* OCEANBASE_UNITTEST_SQL_ENGINE_SET_OB_SET_TEST_UTIL_H_ */
|
||||
196
unittest/sql/engine/set/set_data_generator.h
Normal file
196
unittest/sql/engine/set/set_data_generator.h
Normal file
@ -0,0 +1,196 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_SET_DATA_GENERATOR_H_
|
||||
#define OCEANBASE_SET_DATA_GENERATOR_H_
|
||||
|
||||
#include <functional>
|
||||
#include "sql/engine/ob_phy_operator.h"
|
||||
#include "sql/engine/ob_exec_context.h"
|
||||
|
||||
namespace oceanbase {
|
||||
namespace sql {
|
||||
class SetDataGenerator : public ObPhyOperator {
|
||||
public:
|
||||
const static int64_t ROW_ID_CELL = 0;
|
||||
const static int64_t IDX_CELL = 1;
|
||||
const static int64_t STR_CELL = 2;
|
||||
const static int64_t CELL_CNT = 3;
|
||||
|
||||
const static int64_t INT_VARCHAR_BUF_SIZE = 10;
|
||||
|
||||
class Ctx : public ObPhyOperatorCtx {
|
||||
public:
|
||||
Ctx(ObExecContext& c) : ObPhyOperatorCtx(c)
|
||||
{}
|
||||
virtual void destroy()
|
||||
{
|
||||
return ObPhyOperatorCtx::destroy_base();
|
||||
}
|
||||
};
|
||||
|
||||
explicit SetDataGenerator(common::ObIAllocator& alloc) : ObPhyOperator(alloc)
|
||||
{
|
||||
type_ = PHY_TABLE_SCAN;
|
||||
}
|
||||
|
||||
virtual int set_child(int32_t, ObPhyOperator&)
|
||||
{
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
virtual ObPhyOperator* get_child(int32_t) const
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
virtual int32_t get_child_num() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
virtual int inner_get_next_row(ObExecContext&, const common::ObNewRow*&) const
|
||||
{
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
int close(ObExecContext&) const
|
||||
{
|
||||
return common::OB_SUCCESS;
|
||||
}
|
||||
|
||||
~SetDataGenerator()
|
||||
{
|
||||
if (str_) {
|
||||
delete[] str_;
|
||||
str_ = NULL;
|
||||
}
|
||||
if (projector_) {
|
||||
delete[] projector_;
|
||||
projector_ = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
// row_cnt_ idx_cnt_func_ must set before init
|
||||
int test_init()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (NULL == projector_) {
|
||||
projector_ = new int32_t[CELL_CNT];
|
||||
projector_size_ = CELL_CNT;
|
||||
for (int i = 0; i < CELL_CNT; i++) {
|
||||
projector_[i] = i;
|
||||
}
|
||||
}
|
||||
set_column_count(CELL_CNT);
|
||||
|
||||
row_id_ = 0;
|
||||
if (reverse_) {
|
||||
row_id_ = row_cnt_ - 1;
|
||||
}
|
||||
str_ = new char[string_size_];
|
||||
memset(str_, 'x', string_size_);
|
||||
row_.cells_ = cells_;
|
||||
row_.count_ = CELL_CNT;
|
||||
row_.projector_size_ = projector_size_;
|
||||
row_.projector_ = projector_;
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual int init_op_ctx(ObExecContext& ec) const override
|
||||
{
|
||||
Ctx* ctx = NULL;
|
||||
return CREATE_PHY_OPERATOR_CTX(Ctx, ec, get_id(), get_type(), ctx);
|
||||
}
|
||||
|
||||
virtual int inner_open(ObExecContext& ec) const override
|
||||
{
|
||||
return init_op_ctx(ec);
|
||||
}
|
||||
|
||||
void next_row_id() const
|
||||
{
|
||||
row_id_ += !reverse_ ? 1 : -1;
|
||||
idx_ = 0;
|
||||
idx_cnt_ = 0;
|
||||
}
|
||||
|
||||
virtual int get_next_row(ObExecContext&, const common::ObNewRow*& row) const override
|
||||
{
|
||||
while (true) {
|
||||
if (row_id_ < 0 || row_id_ >= row_cnt_) {
|
||||
row = NULL;
|
||||
return iter_end_ret_;
|
||||
}
|
||||
if (idx_cnt_ == 0) {
|
||||
idx_cnt_ = idx_cnt_func_(row_id_, row_cnt_);
|
||||
}
|
||||
if (idx_ < idx_cnt_) {
|
||||
construct_row();
|
||||
row = &row_;
|
||||
idx_++;
|
||||
return OB_SUCCESS;
|
||||
}
|
||||
if (idx_ >= idx_cnt_) {
|
||||
next_row_id();
|
||||
}
|
||||
}
|
||||
return OB_SUCCESS;
|
||||
}
|
||||
|
||||
void construct_row() const
|
||||
{
|
||||
|
||||
int64_t rand = murmurhash64A(&row_id_, sizeof(row_id_), 0);
|
||||
rand = murmurhash64A(&idx_, sizeof(idx_), (uint64_t)rand);
|
||||
ObObj* objs[] = {&cells_[ROW_ID_CELL], &cells_[IDX_CELL]};
|
||||
int64_t ints[] = {row_id_val_(row_id_), idx_val_(idx_), rand};
|
||||
if (!gen_varchar_cell_) {
|
||||
for (int64_t i = 0; i < ARRAYSIZEOF(objs); i++) {
|
||||
objs[i]->set_int(ints[i]);
|
||||
}
|
||||
} else {
|
||||
char* bufs[] = {
|
||||
&int_varchar_buf_[ROW_ID_CELL * INT_VARCHAR_BUF_SIZE], &int_varchar_buf_[IDX_CELL * INT_VARCHAR_BUF_SIZE]};
|
||||
|
||||
for (int64_t i = 0; i < ARRAYSIZEOF(objs); i++) {
|
||||
snprintf(bufs[i], INT_VARCHAR_BUF_SIZE, "%0.*ld", (int)INT_VARCHAR_BUF_SIZE, ints[i]);
|
||||
objs[i]->set_varchar(bufs[i], INT_VARCHAR_BUF_SIZE);
|
||||
objs[i]->set_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN);
|
||||
}
|
||||
}
|
||||
cells_[STR_CELL].set_varchar(str_, string_size_);
|
||||
cells_[STR_CELL].set_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN);
|
||||
}
|
||||
|
||||
public:
|
||||
bool gen_varchar_cell_ = false;
|
||||
int64_t row_cnt_ = 1;
|
||||
bool reverse_ = false;
|
||||
int string_size_ = 64;
|
||||
typedef std::function<int64_t(const int64_t, const int64_t)> IdxCntFunc;
|
||||
IdxCntFunc idx_cnt_func_ = [](const int64_t, const int64_t) { return 1; };
|
||||
typedef std::function<int64_t(const int64_t)> IdValFunc;
|
||||
IdValFunc row_id_val_ = [](const int64_t v) { return v; };
|
||||
IdValFunc idx_val_ = [](const int64_t v) { return v; };
|
||||
int iter_end_ret_ = OB_ITER_END;
|
||||
|
||||
private:
|
||||
mutable common::ObNewRow row_;
|
||||
mutable common::ObObj cells_[CELL_CNT];
|
||||
mutable int64_t row_id_ = 0;
|
||||
mutable int64_t idx_ = 0;
|
||||
mutable int64_t idx_cnt_ = 0;
|
||||
mutable char* str_ = NULL;
|
||||
mutable char int_varchar_buf_[CELL_CNT * INT_VARCHAR_BUF_SIZE];
|
||||
};
|
||||
|
||||
} // namespace sql
|
||||
} // namespace oceanbase
|
||||
|
||||
#endif // OCEANBASE_SET_DATA_GENERATOR_H_
|
||||
762
unittest/sql/engine/set/test_hash_set_dump.cpp
Normal file
762
unittest/sql/engine/set/test_hash_set_dump.cpp
Normal file
@ -0,0 +1,762 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define USING_LOG_PREFIX SQL
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#define private public
|
||||
#define protected public
|
||||
|
||||
#include "sql/engine/set/ob_hash_union.h"
|
||||
#include "sql/engine/set/ob_hash_intersect.h"
|
||||
#include "sql/engine/set/ob_hash_except.h"
|
||||
#include "sql/engine/set/ob_merge_union.h"
|
||||
#include "sql/engine/set/ob_merge_intersect.h"
|
||||
#include "sql/engine/set/ob_merge_except.h"
|
||||
#include "share/system_variable/ob_system_variable.h"
|
||||
#include "storage/blocksstable/ob_data_file_prepare.h"
|
||||
#include "sql/engine/table/ob_fake_table.h"
|
||||
#include "set_data_generator.h"
|
||||
#include "sql/ob_sql_init.h"
|
||||
#include "share/ob_cluster_version.h"
|
||||
#include "observer/omt/ob_tenant_config_mgr.h"
|
||||
#include "observer/ob_server.h"
|
||||
namespace oceanbase {
|
||||
namespace sql {
|
||||
using namespace common;
|
||||
using namespace share;
|
||||
using namespace omt;
|
||||
|
||||
class MockSqlExpression : public ObSqlExpression {
|
||||
public:
|
||||
MockSqlExpression(ObIAllocator& alloc) : ObSqlExpression(alloc)
|
||||
{
|
||||
set_item_count(10);
|
||||
}
|
||||
};
|
||||
|
||||
#define TEST_SET_DUMP_GET_HASH_AREA_SIZE() (get_hash_area_size())
|
||||
#define TEST_SET_DUMP_SET_HASH_AREA_SIZE(size) (set_hash_area_size(size))
|
||||
|
||||
class ObHashSetDumpTest : public blocksstable::TestDataFilePrepare, public ::testing::WithParamInterface<ObJoinType> {
|
||||
public:
|
||||
enum TestAlgo { UNION = 0, INTERSECT, EXCEPT };
|
||||
|
||||
protected:
|
||||
struct SetPlan {
|
||||
explicit SetPlan(ObIAllocator& alloc) : set_op_(nullptr), left_(alloc), right_(alloc), expr_(alloc)
|
||||
{}
|
||||
|
||||
int setup_plan(ObSetOperator* set_op);
|
||||
|
||||
ObSQLSessionInfo session_;
|
||||
ObPhysicalPlan plan_;
|
||||
ObExecContext exec_ctx_;
|
||||
ObSetOperator* set_op_;
|
||||
SetDataGenerator left_;
|
||||
SetDataGenerator right_;
|
||||
MockSqlExpression expr_;
|
||||
};
|
||||
|
||||
public:
|
||||
ObHashSetDumpTest()
|
||||
: blocksstable::TestDataFilePrepare("TestDiskIR", 8 << 20, 5000),
|
||||
hash_union_(alloc_),
|
||||
merge_union_(alloc_),
|
||||
hash_intersect_(alloc_),
|
||||
merge_intersect_(alloc_),
|
||||
hash_except_(alloc_),
|
||||
merge_except_(alloc_),
|
||||
hash_set_op_(nullptr),
|
||||
merge_set_op_(nullptr),
|
||||
hash_plan_(alloc_),
|
||||
merge_plan_(alloc_)
|
||||
{}
|
||||
|
||||
int init_tenant_mgr();
|
||||
virtual void SetUp() override
|
||||
{
|
||||
ASSERT_EQ(OB_SUCCESS, init_tenant_mgr());
|
||||
blocksstable::TestDataFilePrepare::SetUp();
|
||||
ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().init());
|
||||
ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().start());
|
||||
CHUNK_MGR.set_limit(128L * 1024L * 1024L * 1024L);
|
||||
GCONF.enable_sql_operator_dump.set_value("True");
|
||||
uint64_t cluster_version = CLUSTER_VERSION_3000;
|
||||
common::ObClusterVersion::get_instance().update_cluster_version(cluster_version);
|
||||
EXPECT_EQ(cluster_version, common::ObClusterVersion::get_instance().get_cluster_version());
|
||||
LOG_INFO(
|
||||
"set cluster version", K(cluster_version), K(common::ObClusterVersion::get_instance().get_cluster_version()));
|
||||
OBSERVER.init_schema();
|
||||
OBSERVER.init_tz_info_mgr();
|
||||
}
|
||||
virtual void TearDown() override
|
||||
{
|
||||
blocksstable::ObTmpFileManager::get_instance().destroy();
|
||||
blocksstable::TestDataFilePrepare::TearDown();
|
||||
destroy_tenant_mgr();
|
||||
}
|
||||
|
||||
void destroy_tenant_mgr()
|
||||
{
|
||||
ObTenantManager::get_instance().destroy();
|
||||
}
|
||||
|
||||
int64_t get_hash_area_size()
|
||||
{
|
||||
int64_t hash_area_size = 0;
|
||||
int ret = OB_SUCCESS;
|
||||
ret = ObSqlWorkareaUtil::get_workarea_size(HASH_WORK_AREA, OB_SYS_TENANT_ID, hash_area_size);
|
||||
if (OB_FAIL(ret)) {
|
||||
LOG_WARN("failed to get hash area size", K(ret), K(hash_area_size));
|
||||
}
|
||||
return hash_area_size;
|
||||
}
|
||||
|
||||
void set_hash_area_size(int64_t size)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
int64_t tenant_id = OB_SYS_TENANT_ID;
|
||||
ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
|
||||
if (tenant_config.is_valid()) {
|
||||
tenant_config->_hash_area_size = size;
|
||||
} else {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected status: config is invalid", K(tenant_id));
|
||||
}
|
||||
// ASSERT_EQ(OB_SUCCESS, ret);
|
||||
}
|
||||
|
||||
void setup_plan(SetPlan& plan, bool hash_algo, ObHashSetDumpTest::TestAlgo algo);
|
||||
void setup_test(TestAlgo algo, int32_t string_size, int64_t left_row_count, bool left_reverse,
|
||||
SetDataGenerator::IdxCntFunc left_func, int64_t right_row_count, bool right_reverse,
|
||||
SetDataGenerator::IdxCntFunc right_func);
|
||||
|
||||
// iterate hash join result and verify result with merge join.
|
||||
void run_test(int64_t print_row_cnt = 0);
|
||||
|
||||
protected:
|
||||
ObArenaAllocator alloc_;
|
||||
|
||||
ObHashUnion hash_union_;
|
||||
ObMergeUnion merge_union_;
|
||||
|
||||
ObHashIntersect hash_intersect_;
|
||||
ObMergeIntersect merge_intersect_;
|
||||
|
||||
ObHashExcept hash_except_;
|
||||
ObMergeExcept merge_except_;
|
||||
|
||||
ObSetOperator* hash_set_op_;
|
||||
ObSetOperator* merge_set_op_;
|
||||
|
||||
SetPlan hash_plan_;
|
||||
SetPlan merge_plan_;
|
||||
};
|
||||
|
||||
int ObHashSetDumpTest::SetPlan::setup_plan(ObSetOperator* set_op)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
left_.set_id(0);
|
||||
right_.set_id(1);
|
||||
set_op_ = set_op;
|
||||
set_op_->set_id(2);
|
||||
|
||||
set_op_->set_column_count(SetDataGenerator::CELL_CNT * 2);
|
||||
|
||||
left_.set_phy_plan(&plan_);
|
||||
right_.set_phy_plan(&plan_);
|
||||
set_op_->set_phy_plan(&plan_);
|
||||
set_op_->create_child_array(2);
|
||||
if (OB_FAIL(set_op_->set_child(0, right_))) {
|
||||
} else if (OB_FAIL(set_op_->set_child(1, left_))) {
|
||||
}
|
||||
|
||||
set_op_->set_distinct(true);
|
||||
|
||||
// setup context
|
||||
ObString tenant_name("test");
|
||||
if (OB_FAIL(ret)) {
|
||||
} else if (OB_FAIL(session_.test_init(0, 0, 0, NULL))) {
|
||||
} else if (OB_FAIL(ObPreProcessSysVars::init_sys_var())) {
|
||||
} else if (OB_FAIL(session_.load_default_sys_variable(false, true))) {
|
||||
} else if (OB_FAIL(session_.init_tenant(tenant_name, OB_SYS_TENANT_ID))) {
|
||||
} else if (FALSE_IT(exec_ctx_.set_my_session(&session_))) {
|
||||
} else if (OB_FAIL(exec_ctx_.init_phy_op(3))) {
|
||||
} else if (OB_FAIL(exec_ctx_.create_physical_plan_ctx())) {
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ObHashSetDumpTest::setup_plan(SetPlan& plan, bool hash_algo, ObHashSetDumpTest::TestAlgo algo)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObMergeSetOperator* merge_op = nullptr;
|
||||
ObHashSetOperator* hash_op = nullptr;
|
||||
switch (algo) {
|
||||
case UNION:
|
||||
if (hash_algo) {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_union_));
|
||||
hash_set_op_ = &hash_union_;
|
||||
hash_op = &hash_union_;
|
||||
} else {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_union_));
|
||||
merge_op = &merge_union_;
|
||||
merge_set_op_ = &merge_union_;
|
||||
}
|
||||
break;
|
||||
case INTERSECT:
|
||||
if (hash_algo) {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_intersect_));
|
||||
hash_set_op_ = &hash_intersect_;
|
||||
hash_op = &hash_intersect_;
|
||||
} else {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_intersect_));
|
||||
merge_op = &merge_intersect_;
|
||||
merge_set_op_ = &merge_intersect_;
|
||||
}
|
||||
break;
|
||||
case EXCEPT:
|
||||
if (hash_algo) {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_except_));
|
||||
hash_set_op_ = &hash_except_;
|
||||
hash_op = &hash_except_;
|
||||
} else {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_except_));
|
||||
merge_op = &merge_except_;
|
||||
merge_set_op_ = &merge_except_;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (nullptr != merge_op) {
|
||||
ASSERT_EQ(OB_SUCCESS, merge_op->init(SetDataGenerator::CELL_CNT));
|
||||
ObOrderDirection direction = NULLS_FIRST_ASC;
|
||||
for (int64_t i = 0; i < SetDataGenerator::CELL_CNT; ++i) {
|
||||
ASSERT_EQ(OB_SUCCESS, merge_op->add_set_direction(direction));
|
||||
}
|
||||
for (int64_t i = 0; i < SetDataGenerator::CELL_CNT && OB_SUCC(ret); ++i) {
|
||||
if (OB_FAIL(merge_op->add_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN))) {
|
||||
LOG_WARN("failed to add collation type", K(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (nullptr != hash_op) {
|
||||
ASSERT_EQ(OB_SUCCESS, hash_op->init(SetDataGenerator::CELL_CNT));
|
||||
for (int64_t i = 0; i < SetDataGenerator::CELL_CNT && OB_SUCC(ret); ++i) {
|
||||
if (OB_FAIL(hash_op->add_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN))) {
|
||||
LOG_WARN("failed to add collation type", K(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ObHashSetDumpTest::setup_test(TestAlgo algo, int32_t string_size, int64_t left_row_count, bool left_reverse,
|
||||
SetDataGenerator::IdxCntFunc left_func, int64_t right_row_count, bool right_reverse,
|
||||
SetDataGenerator::IdxCntFunc right_func)
|
||||
{
|
||||
SetPlan* plans[] = {&hash_plan_, &merge_plan_};
|
||||
for (int i = 0; i < 2; i++) {
|
||||
auto& plan = *plans[i];
|
||||
setup_plan(plan, i == 0 ? true : false, algo);
|
||||
|
||||
plan.left_.row_cnt_ = left_row_count;
|
||||
plan.right_.row_cnt_ = right_row_count;
|
||||
plan.left_.string_size_ = string_size;
|
||||
plan.right_.string_size_ = string_size;
|
||||
if (&plan != &merge_plan_) {
|
||||
plan.left_.reverse_ = left_reverse;
|
||||
plan.right_.reverse_ = right_reverse;
|
||||
}
|
||||
plan.left_.idx_cnt_func_ = left_func;
|
||||
plan.right_.idx_cnt_func_ = right_func;
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, plan.left_.test_init());
|
||||
ASSERT_EQ(OB_SUCCESS, plan.right_.test_init());
|
||||
}
|
||||
}
|
||||
|
||||
void ObHashSetDumpTest::run_test(int64_t print_row_cnt)
|
||||
{
|
||||
ObArenaAllocator alloc;
|
||||
typedef ObArray<int64_t*> ResArray;
|
||||
int64_t res_cell_cnt = SetDataGenerator::CELL_CNT * 2;
|
||||
auto fun = [&](SetPlan& plan, ResArray& res) -> void {
|
||||
ASSERT_EQ(OB_SUCCESS, plan.set_op_->open(plan.exec_ctx_));
|
||||
int ret = OB_SUCCESS;
|
||||
const ObNewRow* row = NULL;
|
||||
int64_t cnt = 0;
|
||||
while (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(plan.set_op_->get_next_row(plan.exec_ctx_, row))) {
|
||||
ASSERT_EQ(OB_ITER_END, ret);
|
||||
} else {
|
||||
if (cnt < print_row_cnt) {
|
||||
LOG_INFO("join res", K(*row));
|
||||
}
|
||||
auto r = static_cast<int64_t*>(alloc.alloc(sizeof(int64_t) * res_cell_cnt));
|
||||
ASSERT_TRUE(NULL != r);
|
||||
for (int64_t i = 0; i < res_cell_cnt; i++) {
|
||||
auto& c = row->cells_[i];
|
||||
if (i < row->count_ && c.get_type() == ObIntType) {
|
||||
r[i] = c.get_int();
|
||||
} else {
|
||||
r[i] = -1;
|
||||
}
|
||||
}
|
||||
ASSERT_EQ(OB_SUCCESS, res.push_back(r));
|
||||
}
|
||||
cnt++;
|
||||
}
|
||||
};
|
||||
|
||||
auto pfunc = [&](int64_t* r) {
|
||||
ObSqlString s;
|
||||
for (int64_t i = 0; i < res_cell_cnt; i++) {
|
||||
s.append_fmt("%ld, ", r[i]);
|
||||
}
|
||||
LOG_INFO("RES:", K(s.ptr()));
|
||||
};
|
||||
|
||||
ResArray hash_res;
|
||||
fun(hash_plan_, hash_res);
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
ResArray merge_res;
|
||||
fun(merge_plan_, merge_res);
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
ASSERT_EQ(hash_res.count(), merge_res.count());
|
||||
auto sort_cmp = [&](int64_t* l, int64_t* r) {
|
||||
for (int64_t i = 0; i < res_cell_cnt; i++) {
|
||||
if (l[i] != r[i]) {
|
||||
return l[i] < r[i];
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
std::sort(&hash_res.at(0), &hash_res.at(0) + hash_res.count(), sort_cmp);
|
||||
std::sort(&merge_res.at(0), &merge_res.at(0) + merge_res.count(), sort_cmp);
|
||||
for (int64_t i = 0; i < hash_res.count(); i++) {
|
||||
if (sort_cmp(hash_res.at(i), merge_res.at(i)) || sort_cmp(merge_res.at(i), hash_res.at(i))) {
|
||||
pfunc(hash_res.at(i));
|
||||
pfunc(merge_res.at(i));
|
||||
ASSERT_FALSE(true);
|
||||
}
|
||||
}
|
||||
|
||||
hash_set_op_->close(hash_plan_.exec_ctx_);
|
||||
merge_set_op_->close(merge_plan_.exec_ctx_);
|
||||
// hash_plan_.~SetPlan();
|
||||
// merge_plan_.~SetPlan();
|
||||
ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().files_.map_.size());
|
||||
}
|
||||
|
||||
int ObHashSetDumpTest::init_tenant_mgr()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObTenantManager& tm = ObTenantManager::get_instance();
|
||||
ObAddr self;
|
||||
oceanbase::rpc::frame::ObReqTransport req_transport(NULL, NULL);
|
||||
oceanbase::obrpc::ObSrvRpcProxy rpc_proxy;
|
||||
oceanbase::obrpc::ObCommonRpcProxy rs_rpc_proxy;
|
||||
oceanbase::share::ObRsMgr rs_mgr;
|
||||
uint64_t cluster_version = CLUSTER_VERSION_3000;
|
||||
common::ObClusterVersion::get_instance().update_cluster_version(cluster_version);
|
||||
EXPECT_EQ(cluster_version, common::ObClusterVersion::get_instance().get_cluster_version());
|
||||
int64_t tenant_id = OB_SYS_TENANT_ID;
|
||||
self.set_ip_addr("127.0.0.1", 8086);
|
||||
ret = ObTenantConfigMgr::get_instance().add_tenant_config(tenant_id);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = tm.init(self, rpc_proxy, rs_rpc_proxy, rs_mgr, &req_transport, &ObServerConfig::get_instance());
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = tm.add_tenant(tenant_id);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = tm.set_tenant_mem_limit(tenant_id, 4L * 1024L * 1024L * 1024L, 8L * 1024L * 1024L * 1024L);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = tm.add_tenant(OB_SERVER_TENANT_ID);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
const int64_t ulmt = 256LL << 30;
|
||||
const int64_t llmt = 256LL << 30;
|
||||
ret = tm.set_tenant_mem_limit(OB_SYS_TENANT_ID, ulmt, llmt);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = tm.set_tenant_mem_limit(OB_SERVER_TENANT_ID, ulmt, llmt);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
lib::ObTenantCtxAllocator* ctx_allocator = lib::ObMallocAllocator::get_instance()->get_tenant_ctx_allocator(
|
||||
OB_SERVER_TENANT_ID, common::ObCtxIds::DEFAULT_CTX_ID);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
ret = ctx_allocator->set_limit(8L * 1024L * 1024L * 1024L);
|
||||
EXPECT_EQ(OB_SUCCESS, ret);
|
||||
oceanbase::lib::set_memory_limit(128LL << 32);
|
||||
return ret;
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_single)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::UNION,
|
||||
512,
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_except)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::EXCEPT,
|
||||
512,
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_intersect)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::INTERSECT,
|
||||
512,
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
|
||||
1000,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_dump_union)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::UNION,
|
||||
2000,
|
||||
200000 * 3,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
200000 * 5,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_dump_intersect)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::INTERSECT,
|
||||
2000,
|
||||
200000 * 3,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
200000 * 5,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
TEST_F(ObHashSetDumpTest, test_dump_except)
|
||||
{
|
||||
setup_test(
|
||||
ObHashSetDumpTest::TestAlgo::EXCEPT,
|
||||
2000,
|
||||
200000 * 3,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
200000 * 5,
|
||||
false,
|
||||
[](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
run_test();
|
||||
ASSERT_FALSE(HasFatalFailure());
|
||||
}
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, Size20M_union)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
|
||||
// 200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, Size20M_intersect)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
|
||||
// 200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, Size20M_except)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
|
||||
// 200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_more_data_union)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
|
||||
// 100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_more_data_intersect)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
|
||||
// 100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_more_data_except)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
|
||||
// 100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_left_union)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_left_intersect)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_left_except)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_right_union)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_right_intersect)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
// TEST_F(ObHashSetDumpTest, test_bigger_right_except)
|
||||
// {
|
||||
// int64_t hash_mem = 0;
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ(100 * 1024 * 1024, hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);
|
||||
|
||||
// setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
|
||||
// 2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
|
||||
// 2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
// run_test(10);
|
||||
// ASSERT_FALSE(HasFatalFailure());
|
||||
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((20 * 1024 * 1024), hash_mem);
|
||||
// TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
|
||||
// hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
|
||||
// ASSERT_EQ((100 * 1024 * 1024), hash_mem);
|
||||
// }
|
||||
|
||||
} // namespace sql
|
||||
} // namespace oceanbase
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
oceanbase::sql::init_sql_factories();
|
||||
OB_LOGGER.set_log_level("INFO");
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
int ret = RUN_ALL_TESTS();
|
||||
OB_LOGGER.disable();
|
||||
return ret;
|
||||
}
|
||||
400
unittest/sql/engine/set/test_merge_except.cpp
Normal file
400
unittest/sql/engine/set/test_merge_except.cpp
Normal file
@ -0,0 +1,400 @@
|
||||
/**
|
||||
* 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>
|
||||
#define private public
|
||||
#define protected public
|
||||
#include "sql/engine/set/ob_set_test_util.h"
|
||||
#include "sql/ob_sql_init.h"
|
||||
#include "sql/engine/set/ob_merge_except.h"
|
||||
#include "sql/engine/table/ob_fake_table.h"
|
||||
#include "observer/ob_server.h"
|
||||
#include "observer/ob_server_struct.h"
|
||||
#include "sql/session/ob_sql_session_info.h"
|
||||
#include "share/ob_tenant_mgr.h"
|
||||
|
||||
using namespace oceanbase::common;
|
||||
using namespace oceanbase::sql;
|
||||
using namespace oceanbase::observer;
|
||||
|
||||
class TestMergeExcept : public ObMergeExcept {
|
||||
public:
|
||||
TestMergeExcept() : ObMergeExcept(alloc_)
|
||||
{}
|
||||
~TestMergeExcept()
|
||||
{}
|
||||
};
|
||||
|
||||
class TestMergeExceptTest : public ::testing::Test {
|
||||
public:
|
||||
TestMergeExceptTest();
|
||||
virtual ~TestMergeExceptTest();
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
private:
|
||||
// disallow copy
|
||||
TestMergeExceptTest(const TestMergeExceptTest& other);
|
||||
TestMergeExceptTest& operator=(const TestMergeExceptTest& other);
|
||||
|
||||
private:
|
||||
// data members
|
||||
};
|
||||
TestMergeExceptTest::TestMergeExceptTest()
|
||||
{}
|
||||
|
||||
TestMergeExceptTest::~TestMergeExceptTest()
|
||||
{}
|
||||
|
||||
void TestMergeExceptTest::SetUp()
|
||||
{}
|
||||
|
||||
void TestMergeExceptTest::TearDown()
|
||||
{}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_all_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_all_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_all_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_all_get_next_row4)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_distinct_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_distinct_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_distinct_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_except_distinct_bug)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 1, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1));
|
||||
ADD_ROW(fake_table1, COL(2));
|
||||
ADD_ROW(fake_table1, COL(2));
|
||||
ADD_ROW(fake_table1, COL(3));
|
||||
ADD_ROW(fake_table1, COL(3));
|
||||
ADD_ROW(fake_table2, COL(1));
|
||||
ADD_ROW(fake_table2, COL(3));
|
||||
ADD_ROW(fake_table2, COL(3));
|
||||
ADD_ROW(result_table, COL(2));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 1, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_distinct_with_direction_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = true;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeExceptTest, test_all_with_direction_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeExcept merge_except;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = true;
|
||||
TestSetOperatorFactory::init(ctx, &merge_except, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_except, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_except.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
init_global_memory_pool();
|
||||
init_sql_factories();
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
int ret = RUN_ALL_TESTS();
|
||||
OB_LOGGER.disable();
|
||||
return ret;
|
||||
}
|
||||
401
unittest/sql/engine/set/test_merge_intersect.cpp
Normal file
401
unittest/sql/engine/set/test_merge_intersect.cpp
Normal file
@ -0,0 +1,401 @@
|
||||
/**
|
||||
* 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>
|
||||
#define private public
|
||||
#define protected public
|
||||
#include "sql/engine/set/ob_set_test_util.h"
|
||||
#include "sql/ob_sql_init.h"
|
||||
#include "sql/engine/set/ob_merge_intersect.h"
|
||||
#include "sql/engine/table/ob_fake_table.h"
|
||||
#include "sql/session/ob_sql_session_info.h"
|
||||
#include "observer/ob_server.h"
|
||||
#include "observer/ob_server_struct.h"
|
||||
#include "share/ob_tenant_mgr.h"
|
||||
|
||||
using namespace oceanbase::common;
|
||||
using namespace oceanbase::sql;
|
||||
using namespace oceanbase::observer;
|
||||
class TestMergeIntersect : public ObMergeIntersect {
|
||||
public:
|
||||
TestMergeIntersect() : ObMergeIntersect(alloc_)
|
||||
{}
|
||||
virtual ~TestMergeIntersect()
|
||||
{}
|
||||
};
|
||||
|
||||
class TestMergeIntersectTest : public ::testing::Test {
|
||||
public:
|
||||
TestMergeIntersectTest();
|
||||
virtual ~TestMergeIntersectTest();
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
private:
|
||||
// disallow copy
|
||||
TestMergeIntersectTest(const TestMergeIntersectTest& other);
|
||||
TestMergeIntersectTest& operator=(const TestMergeIntersectTest& other);
|
||||
|
||||
private:
|
||||
// data members
|
||||
};
|
||||
TestMergeIntersectTest::TestMergeIntersectTest()
|
||||
{}
|
||||
|
||||
TestMergeIntersectTest::~TestMergeIntersectTest()
|
||||
{}
|
||||
|
||||
void TestMergeIntersectTest::SetUp()
|
||||
{}
|
||||
|
||||
void TestMergeIntersectTest::TearDown()
|
||||
{}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_fake_table)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObFakeTable fake_table;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
const ObNewRow* row = NULL;
|
||||
ObPhysicalPlan physical_plan;
|
||||
fake_table.set_column_count(5);
|
||||
fake_table.set_id(0);
|
||||
fake_table.set_phy_plan(&physical_plan);
|
||||
ASSERT_EQ(OB_SUCCESS, ctx.init_phy_op(1));
|
||||
ASSERT_EQ(OB_SUCCESS, ctx.create_physical_plan_ctx());
|
||||
|
||||
ADD_ROW(fake_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table, COL(2), COL(3), COL(null), COL(null), COL(null));
|
||||
ADD_ROW(fake_table, COL(3), COL(3), COL(2.0), COL("yuming"), COL("oceanbase"));
|
||||
printf("fake_table: \n%s\n", to_cstring(fake_table));
|
||||
ASSERT_EQ(OB_SUCCESS, fake_table.open(ctx));
|
||||
while (OB_SUCCESS == (ret = fake_table.get_next_row(ctx, row))) {
|
||||
printf("row=%s\n", to_cstring(*row));
|
||||
}
|
||||
ASSERT_EQ(OB_ITER_END, ret);
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_all_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_all_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_all_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_all_get_next_row4)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
const ObNewRow* row = NULL;
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_ITER_END, merge_intersect.get_next_row(ctx, row));
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_distinct_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_distinct_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_distinct_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
const ObNewRow* row = NULL;
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_ITER_END, merge_intersect.get_next_row(ctx, row));
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, invalid_argument)
|
||||
{
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
ASSERT_EQ(OB_NOT_INIT, merge_intersect.open(ctx));
|
||||
merge_intersect.reset();
|
||||
merge_intersect.reuse();
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_distinct_with_direction_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
bool set_direction = true;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeIntersectTest, test_all_with_direction_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeIntersect merge_intersect;
|
||||
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = true;
|
||||
TestSetOperatorFactory::init(ctx, &merge_intersect, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(4), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("xuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(4), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT_SET(ctx, result_table, merge_intersect, 0, 5, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_intersect.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
OB_LOGGER.set_log_level("INFO");
|
||||
init_global_memory_pool();
|
||||
init_sql_factories();
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
int ret = RUN_ALL_TESTS();
|
||||
OB_LOGGER.disable();
|
||||
return ret;
|
||||
}
|
||||
389
unittest/sql/engine/set/test_merge_union.cpp
Normal file
389
unittest/sql/engine/set/test_merge_union.cpp
Normal file
@ -0,0 +1,389 @@
|
||||
/**
|
||||
* 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>
|
||||
#define private public
|
||||
#define protected public
|
||||
#include "sql/session/ob_sql_session_info.h"
|
||||
#include "sql/engine/set/ob_set_test_util.h"
|
||||
#include "sql/ob_sql_init.h"
|
||||
#include "sql/engine/set/ob_merge_union.h"
|
||||
#include "sql/engine/table/ob_fake_table.h"
|
||||
#include "observer/ob_server.h"
|
||||
#include "observer/ob_server_struct.h"
|
||||
#include "share/ob_tenant_mgr.h"
|
||||
|
||||
using namespace oceanbase::common;
|
||||
using namespace oceanbase::sql;
|
||||
using namespace oceanbase::observer;
|
||||
|
||||
class TestMergeUnion : public ObMergeUnion {
|
||||
public:
|
||||
TestMergeUnion() : ObMergeUnion(alloc_)
|
||||
{}
|
||||
virtual ~TestMergeUnion()
|
||||
{}
|
||||
};
|
||||
|
||||
class TestMergeUnionTest : public ::testing::Test {
|
||||
public:
|
||||
TestMergeUnionTest();
|
||||
virtual ~TestMergeUnionTest();
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
protected:
|
||||
private:
|
||||
// disallow copy
|
||||
TestMergeUnionTest(const TestMergeUnionTest& other);
|
||||
TestMergeUnionTest& operator=(const TestMergeUnionTest& other);
|
||||
|
||||
private:
|
||||
// data members
|
||||
};
|
||||
TestMergeUnionTest::TestMergeUnionTest()
|
||||
{}
|
||||
|
||||
TestMergeUnionTest::~TestMergeUnionTest()
|
||||
{}
|
||||
|
||||
void TestMergeUnionTest::SetUp()
|
||||
{}
|
||||
|
||||
void TestMergeUnionTest::TearDown()
|
||||
{}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_all_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL(null), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("oceanbase"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_all_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_all_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
const ObNewRow* row = NULL;
|
||||
TestMergeUnion merge_union;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, false, set_direction);
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ret = merge_union.get_next_row(ctx, row);
|
||||
ASSERT_EQ(OB_ITER_END, ret);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_all_get_next_row4)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_GENERAL_CI;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, false, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(2), COL(null), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(5), COL(2), COL(4), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(6), COL(2), COL(4), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(6), COL(2), COL(4), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(7), COL(2), COL(4), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(3), COL(15), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(2), COL(3), COL(15), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(fake_table2, COL(3), COL(2), COL(null), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(4), COL(2), COL(16), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(8), COL(2), COL(16), COL("oceanbase"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL("1"), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(3), COL("15"), COL("yuming"), COL("oceanbase"));
|
||||
ADD_ROW(result_table, COL(3), COL(2), COL(null), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(4), COL(2), COL("16"), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(5), COL(2), COL("4"), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(6), COL(2), COL("4"), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(7), COL(2), COL("4"), COL("oceanbase"), COL(null));
|
||||
ADD_ROW(result_table, COL(8), COL(2), COL("16"), COL("oceanbase"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(2), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table1, COL(3), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(fake_table2, COL(2), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(2), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(3), COL(2), COL(1.1), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row3)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row4)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
const ObNewRow* row = NULL;
|
||||
TestMergeUnion merge_union;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, true, set_direction);
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ret = merge_union.get_next_row(ctx, row);
|
||||
ASSERT_EQ(OB_ITER_END, ret);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row5)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 5, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table2, COL(1), COL(2), COL(1), COL("yuchen.wyc"), COL(null));
|
||||
ADD_ROW(result_table, COL(1), COL(2), COL(1), COL("yuchen.wyc"), COL(null));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_get_next_row6)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = false;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 2, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL("1"), COL("a"));
|
||||
ADD_ROW(fake_table1, COL("2"), COL("b"));
|
||||
ADD_ROW(fake_table2, COL("a"), COL("1"));
|
||||
ADD_ROW(fake_table2, COL("b"), COL("2"));
|
||||
|
||||
ADD_ROW(result_table, COL("1"), COL("a"));
|
||||
ADD_ROW(result_table, COL("2"), COL("b"));
|
||||
ADD_ROW(result_table, COL("a"), COL("1"));
|
||||
ADD_ROW(result_table, COL("b"), COL("2"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
TEST_F(TestMergeUnionTest, test_distinct_with_direction_get_next_row1)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObExecContext ctx;
|
||||
ObSQLSessionInfo my_session;
|
||||
ASSERT_EQ(OB_SUCCESS, my_session.test_init(0, 0, 0, NULL));
|
||||
ctx.set_my_session(&my_session);
|
||||
ObFakeTable& fake_table1 = TestSetOperatorFactory::get_fake_table1();
|
||||
ObFakeTable& fake_table2 = TestSetOperatorFactory::get_fake_table2();
|
||||
ObFakeTable& result_table = TestSetOperatorFactory::get_result_table();
|
||||
TestMergeUnion merge_union;
|
||||
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
|
||||
|
||||
bool set_direction = true;
|
||||
TestSetOperatorFactory::init(ctx, &merge_union, 2, true, set_direction);
|
||||
// prepare rows, equal in the first row
|
||||
ADD_ROW(fake_table1, COL("1"), COL("a"));
|
||||
ADD_ROW(fake_table1, COL("2"), COL("b"));
|
||||
ADD_ROW(fake_table2, COL("1"), COL("c"));
|
||||
ADD_ROW(fake_table2, COL("2"), COL("c"));
|
||||
|
||||
ADD_ROW(result_table, COL("1"), COL("c"));
|
||||
ADD_ROW(result_table, COL("1"), COL("b"));
|
||||
ADD_ROW(result_table, COL("2"), COL("c"));
|
||||
ADD_ROW(result_table, COL("2"), COL("b"));
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.open(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
|
||||
EXCEPT_RESULT(ctx, result_table, merge_union, agg_cs_type);
|
||||
ASSERT_EQ(OB_SUCCESS, merge_union.close(ctx));
|
||||
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
|
||||
}
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
init_global_memory_pool();
|
||||
init_sql_factories();
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
int ret = RUN_ALL_TESTS();
|
||||
OB_LOGGER.disable();
|
||||
return ret;
|
||||
}
|
||||
Reference in New Issue
Block a user