hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
d9e7a0218f4f97f70837c4d3253081f23e2bc417
oceanbase/unittest/sql/engine/recursive_cte/test_recursive_cte.cpp
wangzelin.wzl 93a1074b0c patch 4.0
2022-10-24 17:57:12 +08:00

612 lines
28 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#include <gtest/gtest.h>
#include "sql/ob_sql_init.h"
#include "sql/engine/set/ob_merge_union.h"
#include "sql/engine/table/ob_fake_table.h"
#include "sql/engine/recursive_cte/ob_recursive_cte_util.h"
#include "observer/ob_server.h"
#include "observer/ob_server_struct.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
using namespace oceanbase::observer;
class RecursiveCTETester : public ObRecursiveUnionAll
{
public:
RecursiveCTETester() :ObRecursiveUnionAll(alloc_) {}
virtual ~RecursiveCTETester() {}
};
class TestRecusiveUnionAll: public ::testing::Test
{
public:
TestRecusiveUnionAll();
virtual ~TestRecusiveUnionAll();
virtual void SetUp();
virtual void TearDown();
void except_result_with_row_count(ObExecContext& _ctx, ObFakeTable& _result_table,
uint64_t _count, RecursiveCTETester& op,
uint64_t start_idx,
uint64_t end_idx,
ObCollationType& collation) {
int ret = OB_SUCCESS;
UNUSED(start_idx);
UNUSED(end_idx);
UNUSED(collation);
if (OB_SUCC(ret)) {
const ObNewRow *result_row = NULL;
uint64_t j = 0;
while(j < _count && (OB_SUCCESS == (ret = op.get_next_row(_ctx, result_row)))) {
j++;
const ObNewRow *except_row = NULL;
//printf("row=%s\n", to_cstring(*result_row));
ASSERT_EQ(OB_SUCCESS, _result_table.get_next_row(_ctx, except_row));
//printf("except_row=%s\n", to_cstring(*except_row));
ASSERT_TRUE(except_row->count_ == result_row->count_);
/*for (int64_t i = start_idx; i < end_idx; ++i) {
printf("index=%ld, cell=%s, respect_cell=%s\n", i, to_cstring(result_row->cells_[i]), to_cstring(except_row->cells_[i]));
ASSERT_TRUE(0 == except_row->cells_[i].compare(result_row->cells_[i], collation));
}*/
result_row = NULL;
}
}
}
protected:
private:
// disallow copy
TestRecusiveUnionAll(const TestRecusiveUnionAll &other);
TestRecusiveUnionAll& operator=(const TestRecusiveUnionAll &other);
private:
// data members
};
TestRecusiveUnionAll::TestRecusiveUnionAll()
{
}
TestRecusiveUnionAll::~TestRecusiveUnionAll()
{
}
void TestRecusiveUnionAll::SetUp()
{
}
void TestRecusiveUnionAll::TearDown()
{
}
TEST_F(TestRecusiveUnionAll, test_recursive_cte_muti_round_breadth)
{
int ret = OB_SUCCESS;
ObExecContext ctx;
const ObNewRow* row = NULL;
ObFakeTable &planA_output_table = TestRecursiveCTEFactory::get_planA_op_();
ObFakeTable &planB_output_table = TestRecursiveCTEFactory::get_planB_op_();
planB_output_table.set_no_rescan();
ObFakeTable &result_table = TestRecursiveCTEFactory::get_result_table();
RecursiveCTETester recursive_cte;
recursive_cte.init_cte_pseudo_column();
ObFakeCTETable fake_cte(alloc_);
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
fake_cte.add_column_involved_offset(0);
fake_cte.add_column_involved_offset(1);
fake_cte.add_column_involved_offset(2);
fake_cte.add_column_involved_offset(3);
fake_cte.add_column_involved_offset(4);
TestRecursiveCTEFactory::init(ctx, &recursive_cte, &fake_cte, 5);
ASSERT_EQ(OB_SUCCESS, recursive_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
//第一轮不会产生数据，因为planb并不会被访问到，但是会有数据向fake cte table 输出，即A
//下一论出来的数据则是A被拿去planb中查处来的数据
ADD_ROW(planA_output_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
ADD_ROW(planA_output_table, COL(2), COL(3), COL(7), COL("B"), COL("oceanbase"));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
ADD_ROW(result_table, COL(2), COL(3), COL(7), COL("B"), COL("oceanbase"));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("BA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_TRUE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("BA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_TRUE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("BA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
const ObNewRow *except_row = NULL;
ASSERT_TRUE( OB_ITER_END == recursive_cte.get_next_row( ctx, except_row));
ASSERT_EQ(OB_SUCCESS, recursive_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
}
TEST_F(TestRecusiveUnionAll, test_recursive_cte_muti_round_depth)
{
int ret = OB_SUCCESS;
ObExecContext ctx;
const ObNewRow* row = NULL;
ObFakeTable &planA_output_table = TestRecursiveCTEFactory::get_planA_op_();
ObFakeTable &planB_output_table = TestRecursiveCTEFactory::get_planB_op_();
planB_output_table.set_no_rescan();
ObFakeTable &result_table = TestRecursiveCTEFactory::get_result_table();
RecursiveCTETester recursive_cte;
recursive_cte.init_cte_pseudo_column();
ObFakeCTETable fake_cte(alloc_);
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
fake_cte.add_column_involved_offset(0);
fake_cte.add_column_involved_offset(1);
fake_cte.add_column_involved_offset(2);
fake_cte.add_column_involved_offset(3);
fake_cte.add_column_involved_offset(4);
TestRecursiveCTEFactory::init_depth(ctx, &recursive_cte, &fake_cte, 5);
ASSERT_EQ(OB_SUCCESS, recursive_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
//第一轮不会产生数据，因为planb并不会被访问到，但是会有数据向fake cte table 输出，即A
//下一论出来的数据则是A被拿去planb中查处来的数据
ADD_ROW(planA_output_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
ADD_ROW(planA_output_table, COL(2), COL(3), COL(7), COL("B"), COL("oceanbase"));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AAB"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AAB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AAB"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
ADD_ROW(result_table, COL(2), COL(3), COL(7), COL("B"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(3), COL(7), COL("B"), COL(null));
const ObNewRow *except_row = NULL;
ASSERT_TRUE( OB_ITER_END == recursive_cte.get_next_row( ctx, except_row));
ASSERT_EQ(OB_SUCCESS, recursive_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
}
TEST_F(TestRecusiveUnionAll, test_recursive_cte_muti_round_depth_search_by_col3)
{
int ret = OB_SUCCESS;
ObExecContext ctx;
const ObNewRow* row = NULL;
ObFakeTable &planA_output_table = TestRecursiveCTEFactory::get_planA_op_();
ObFakeTable &planB_output_table = TestRecursiveCTEFactory::get_planB_op_();
planB_output_table.set_no_rescan();
ObFakeTable &result_table = TestRecursiveCTEFactory::get_result_table();
RecursiveCTETester recursive_cte;
recursive_cte.init_cte_pseudo_column();
ObFakeCTETable fake_cte(alloc_);
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
fake_cte.add_column_involved_offset(0);
fake_cte.add_column_involved_offset(1);
fake_cte.add_column_involved_offset(2);
fake_cte.add_column_involved_offset(3);
fake_cte.add_column_involved_offset(4);
TestRecursiveCTEFactory::init_depth_search_by_col3(ctx, &recursive_cte, &fake_cte, 5);
ASSERT_EQ(OB_SUCCESS, recursive_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
ADD_ROW(planA_output_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
ADD_ROW(planA_output_table, COL(2), COL(3), COL(7), COL("B"), COL("oceanbase"));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("A"), COL(null));
//由于union all 自身关闭了排序逻辑，所以这里必须按序加入结果集
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AD"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAB"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAC"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAD"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAE"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1.0), COL("AAF"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAB"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAC"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAC"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAD"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAD"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAE"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAE"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AAF"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AAF"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AB"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4.0), COL("AC"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1.0), COL("AD"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1.0), COL("AD"), COL(null));
ADD_ROW(result_table, COL(2), COL(3), COL(7), COL("B"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(3), COL(7), COL("B"), COL(null));
const ObNewRow *except_row = NULL;
ASSERT_TRUE( OB_ITER_END == recursive_cte.get_next_row( ctx, except_row));
ASSERT_EQ(OB_SUCCESS, recursive_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
}
TEST_F(TestRecusiveUnionAll, test_recursive_cte_muti_round_breadth_search_by_col3_cycle_by_col2)
{
int ret = OB_SUCCESS;
ObExecContext ctx;
const ObNewRow* row = NULL;
ObFakeTable &planA_output_table = TestRecursiveCTEFactory::get_planA_op_();
ObFakeTable &planB_output_table = TestRecursiveCTEFactory::get_planB_op_();
planB_output_table.set_no_rescan();
ObFakeTable &result_table = TestRecursiveCTEFactory::get_result_table();
RecursiveCTETester recursive_cte;
recursive_cte.init_cte_pseudo_column();
ObFakeCTETable fake_cte(alloc_);
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
fake_cte.add_column_involved_offset(0);
fake_cte.add_column_involved_offset(1);
fake_cte.add_column_involved_offset(2);
fake_cte.add_column_involved_offset(3);
fake_cte.add_column_involved_offset(4);
TestRecursiveCTEFactory::init_breadth_search_by_col3_cyc_by_col2(ctx, &recursive_cte, &fake_cte, 5);
ASSERT_EQ(OB_SUCCESS, recursive_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
//
// 下图展示了测试使用的图，其中AAA与先祖A在列2的值上发生了重复，是重复列。在oracle中测试，同一层的指定值重复也不算环
// A （1） B （2）
// AA（3） AB（4） BA（5）
// AAA（1） ABA（5） BAA (4)
//
//第一轮不会产生数据，因为planb并不会被访问到，但是会有数据向fake cte table 输出，即A
//下一论出来的数据则是A被拿去planb中查处来的数据
ADD_ROW(planA_output_table, COL(1), COL(2), COL(1), COL("A"), COL(null));
ADD_ROW(planA_output_table, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
ADD_ROW(result_table, COL(1), COL(2), COL(1), COL("A"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1), COL("A"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(3), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4), COL("AB"), COL(null));
ADD_ROW(result_table, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(3), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(5), COL("BA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(3), COL("AA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_TRUE(NULL == row);
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(2), COL(2), COL(4), COL("AB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4), COL("AB"), COL(null));
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(5), COL("BA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(5), COL("BA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_TRUE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(5), COL("BA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
//AAA 列2值为1，与A列2值为1重复，A是AAA的先祖，所以AAA不会进入到fake table中，会直接出队
ADD_ROW(result_table, COL(1), COL(2), COL(1), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
except_result_with_row_count(ctx, result_table, 2, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_TRUE(NULL == row);
//EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
const ObNewRow *except_row = NULL;
ASSERT_TRUE( OB_ITER_END == recursive_cte.get_next_row( ctx, except_row));
ASSERT_EQ(OB_SUCCESS, recursive_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
}
TEST_F(TestRecusiveUnionAll, test_recursive_cte_muti_round_depth_search_by_col3_cycle_by_col2)
{
int ret = OB_SUCCESS;
ObExecContext ctx;
const ObNewRow* row = NULL;
ObFakeTable &planA_output_table = TestRecursiveCTEFactory::get_planA_op_();
ObFakeTable &planB_output_table = TestRecursiveCTEFactory::get_planB_op_();
planB_output_table.set_no_rescan();
ObFakeTable &result_table = TestRecursiveCTEFactory::get_result_table();
RecursiveCTETester recursive_cte;
recursive_cte.init_cte_pseudo_column();
ObFakeCTETable fake_cte(alloc_);
ObCollationType agg_cs_type = CS_TYPE_UTF8MB4_BIN;
fake_cte.add_column_involved_offset(0);
fake_cte.add_column_involved_offset(1);
fake_cte.add_column_involved_offset(2);
fake_cte.add_column_involved_offset(3);
fake_cte.add_column_involved_offset(4);
TestRecursiveCTEFactory::init_depth_search_by_col3_cyc_by_col2(ctx, &recursive_cte, &fake_cte, 5);
ASSERT_EQ(OB_SUCCESS, recursive_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.open(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.open(ctx));
//
// 下图展示了测试使用的图，其中AAA与先祖A在列2的值上发生了重复，是重复列。在oracle中测试，同一层的指定值重复也不算环
// 右图是节点在数组tree中的偏移量
// A （1） B （2） uint64 uint64
// AA（3） AB（4） BA（5） 0 0 1
// AAA（1） ABA（5） BAA (4) 2 3 4
//
// 第一轮不会产生数据，因为planb并不会被访问到，但是会有数据向fake cte table 输出，即A
// 下一论出来的数据则是A被拿去planb中查处来的数据
ADD_ROW(planA_output_table, COL(1), COL(2), COL(1), COL("A"), COL(null));
ADD_ROW(planA_output_table, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
ADD_ROW(result_table, COL(1), COL(2), COL(1), COL("A"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(1), COL("A"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(3), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(2), COL(2), COL(4), COL("AB"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(3), COL("AA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(3), COL("AA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(1), COL("AAA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(1), COL("AAA"), COL(null));//由于AAA列2的值为1，与栈顶节点"A"的值一样，因此AAA不会进入到fake cte table算子中
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
//AAA不会进入到fake table中，符合预期
ADD_ROW(result_table, COL(2), COL(2), COL(4), COL("AB"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(2), COL(4), COL("AB"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(5), COL("ABA"), COL(null));
ADD_ROW(result_table, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(2), COL(3), COL(2), COL("B"), COL("oceanbase"));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(5), COL("BA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(5), COL("BA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(5), COL("BA"), COL(null));
ADD_ROW(planB_output_table, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
ADD_ROW(result_table, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
except_result_with_row_count(ctx, result_table, 1, recursive_cte, 0, 4, agg_cs_type);//测试时，内存中的RS栈为 B BA BAA与预期符合
row = NULL;
fake_cte.get_next_row(ctx, row);
ASSERT_FALSE(NULL == row);
EXPECT_SAME_ROW((*row), result_table, 0, 4, agg_cs_type, COL(1), COL(2), COL(4), COL("BAA"), COL(null));
const ObNewRow *except_row = NULL;
ASSERT_TRUE( OB_ITER_END == recursive_cte.get_next_row( ctx, except_row));
ASSERT_EQ(OB_SUCCESS, recursive_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, fake_cte.close(ctx));
ASSERT_EQ(OB_SUCCESS, result_table.close(ctx));
}
int main(int argc, char **argv)
{
system("rm -f test_recursive_cte.log");
init_global_memory_pool();
init_sql_factories();
::testing::InitGoogleTest(&argc,argv);
int ret = RUN_ALL_TESTS();
return ret;
}
Reference in New Issue View Git Blame Copy Permalink