hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
oceanbase/unittest/sql/resolver/test_raw_expr.cpp
xj0 e5f59ea074 support json type
2022-02-08 15:08:04 +08:00

319 lines
12 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 "lib/utility/ob_test_util.h"
#include "sql/parser/ob_parser.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/resolver/expr/ob_raw_expr_print_visitor.h"
#include "sql/resolver/expr/ob_raw_expr_canonicalizer_impl.h"
#include "sql/resolver/expr/ob_raw_expr_resolver_impl.h"
#include "sql/ob_sql_init.h"
#include "../test_sql_utils.h"
#include "lib/json/ob_json_print_utils.h"
#include "sql/resolver/expr/ob_raw_expr_deduce_type.h"
#define private public
#include "sql/resolver/ob_stmt_resolver.h"
#include <fstream>
#include <iterator>
using namespace oceanbase::common;
using namespace oceanbase::sql;
#define BUF_LEN 102400
namespace test {
class TestRawExpr : public TestSqlUtils, public ::testing::Test {
public:
TestRawExpr();
virtual ~TestRawExpr();
virtual void SetUp();
virtual void TearDown();
ObArenaAllocator allocator;
ObRawExprFactory expr_factory_;
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(TestRawExpr);
protected:
// function members
int get_raw_expr(const char* expr, ObRawExpr*& raw_expr, const char*& json_expr);
int get_result_tree(const char* sql, ParseResult& parse_result, ObIAllocator& allocator);
void resolver(const char* expr, const char*& json_expr);
protected:
// data members
};
TestRawExpr::TestRawExpr() : allocator(ObModIds::TEST), expr_factory_(allocator)
{}
TestRawExpr::~TestRawExpr()
{}
void TestRawExpr::SetUp()
{}
void TestRawExpr::TearDown()
{}
int TestRawExpr::get_result_tree(const char* sql, ParseResult& parse_result, ObIAllocator& allocator)
{
ObSQLMode mode = SMO_DEFAULT;
ObParser parser(allocator, mode);
ObString query = ObString::make_string(sql);
int ret = OB_SUCCESS;
ret = parser.parse(query, parse_result);
return ret;
}
int TestRawExpr::get_raw_expr(const char* expr, ObRawExpr*& raw_expr, const char*& json_expr)
{
int ret = OB_SUCCESS;
ObArray<ObRawExpr*> expr_store;
ObArray<ObQualifiedName> columns;
ObArray<ObVarInfo> sys_vars;
ObArray<ObSubQueryInfo> sub_query_info;
ObArray<ObAggFunRawExpr*> aggr_exprs;
ObArray<ObWinFunRawExpr*> win_exprs;
ObArray<ObOpRawExpr*> op_exprs;
ObTimeZoneInfo tz_info;
ObNameCaseMode case_mode = OB_NAME_CASE_INVALID;
ObExprResolveContext ctx(expr_factory_, &tz_info, case_mode);
ctx.connection_charset_ = ObCharset::get_default_charset();
ctx.dest_collation_ = ObCharset::get_default_collation(ctx.connection_charset_);
ObString ob_str(expr);
ret = ObRawExprUtils::make_raw_expr_from_str(
ob_str, ctx, raw_expr, columns, sys_vars, &sub_query_info, aggr_exprs, win_exprs);
UNUSED(json_expr);
return ret;
}
void TestRawExpr::resolver(const char* expr, const char*& json_expr)
{
const char* canon_expr = NULL;
ObRawExpr* raw_expr = NULL;
if (OB_SUCCESS == get_raw_expr(expr, raw_expr, canon_expr)) {
char buf[BUF_LEN];
int64_t pos = 0;
raw_expr->get_name_internal(buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
_OB_LOG(INFO, "===========================================\n");
_OB_LOG(INFO, "%s\n", buf);
json_expr = CSJ(raw_expr);
} else {
json_expr = "ERR----TEST";
}
}
TEST_F(TestRawExpr, basic_test)
{
const char* canon_expr = NULL;
ObRawExpr* praw_expr = NULL;
get_raw_expr("1", praw_expr, canon_expr);
ObRawExprPrintVisitor pvistor(*praw_expr);
ObRawExpr* raw_expr1 = NULL;
get_raw_expr("1", raw_expr1, canon_expr);
ObConstRawExpr* const_expr1 = dynamic_cast<ObConstRawExpr*>(raw_expr1);
ObRawExpr* raw_expr2 = NULL;
get_raw_expr("1.5", raw_expr2, canon_expr);
ObConstRawExpr* const_expr2 = dynamic_cast<ObConstRawExpr*>(raw_expr2);
ASSERT_FALSE(const_expr2->same_as(*const_expr1));
(*const_expr1).assign(*const_expr2);
ASSERT_TRUE(const_expr2->same_as(*const_expr1));
char buf[BUF_LEN];
char str_buf[BUF_LEN];
pvistor.to_string(buf, BUF_LEN);
OK(const_expr1->preorder_accept(pvistor));
OK(const_expr1->postorder_accept(pvistor));
OK(const_expr1->postorder_replace(pvistor));
_OB_LOG(INFO, "\nconst_expr------\n%s ", buf);
int64_t pos = 0;
const_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_FORMAT_JSON);
raw_expr2->reset();
const_expr2->reset();
get_raw_expr("c1 in (select t1 from table1)", raw_expr1, canon_expr);
ObOpRawExpr* op_expr1 = dynamic_cast<ObOpRawExpr*>(raw_expr1);
get_raw_expr("c2 not in (select t2 from table1)", raw_expr2, canon_expr);
ObOpRawExpr* op_expr2 = dynamic_cast<ObOpRawExpr*>(raw_expr2);
ASSERT_FALSE(ObRawExprUtils::is_same_raw_expr(op_expr1, op_expr2));
ObArray<ObRawExpr*> expr_store;
OK(ObRawExprUtils::extract_column_exprs(op_expr1, expr_store));
OK(op_expr1->preorder_accept(pvistor));
OK(op_expr1->postorder_accept(pvistor));
_OB_LOG(INFO, "\nop_expr------\n%s ", buf);
ObColumnRefRawExpr* bin_expr1 = dynamic_cast<ObColumnRefRawExpr*>(op_expr1->get_param_expr(0));
ObColumnRefRawExpr* bin_expr2 = dynamic_cast<ObColumnRefRawExpr*>(op_expr2->get_param_expr(0));
bin_expr1->set_ref_id(1, 1);
bin_expr2->set_ref_id(2, 2);
bin_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
bin_expr2->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
ASSERT_FALSE(bin_expr1->same_as(*bin_expr2));
(*bin_expr1).assign(*bin_expr2);
ASSERT_TRUE(bin_expr1->same_as(*bin_expr2));
ObRawExpr* copy_expr = NULL;
;
ASSERT_EQ(OB_SUCCESS, ObRawExprUtils::copy_expr(expr_factory_, bin_expr1, copy_expr, true, true, true));
ASSERT_TRUE(bin_expr1->same_as(*copy_expr));
OK(bin_expr1->preorder_accept(pvistor));
OK(bin_expr1->postorder_accept(pvistor));
OK(bin_expr1->postorder_replace(pvistor));
_OB_LOG(INFO, "\nbin_expr------\n%s", buf);
ObQueryRefRawExpr* sub_expr1 = dynamic_cast<ObQueryRefRawExpr*>(op_expr1->get_param_expr(1));
ObQueryRefRawExpr* sub_expr2 = dynamic_cast<ObQueryRefRawExpr*>(op_expr2->get_param_expr(1));
OK(ObRawExprUtils::copy_expr(expr_factory_, sub_expr1, copy_expr, false, true, true));
ASSERT_TRUE(sub_expr1->same_as(*sub_expr1));
ObRawExpr* texpr1 = NULL;
ObRawExpr* texpr2 = NULL;
ASSERT_FALSE(ObRawExprUtils::is_same_raw_expr(texpr1, sub_expr2));
ASSERT_TRUE(ObRawExprUtils::is_same_raw_expr(texpr1, texpr2));
sub_expr1->set_ref_id(1);
sub_expr2->set_ref_id(2);
ASSERT_FALSE(ObRawExprUtils::is_same_raw_expr(sub_expr1, sub_expr2));
ASSERT_TRUE(ObRawExprUtils::is_same_raw_expr(sub_expr1, sub_expr1));
ASSERT_FALSE(sub_expr1->same_as(*sub_expr2));
(*sub_expr1).assign(*sub_expr2);
ASSERT_TRUE(sub_expr1->same_as(*sub_expr2));
sub_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
OK(sub_expr1->preorder_accept(pvistor));
OK(sub_expr1->postorder_accept(pvistor));
OK(sub_expr1->postorder_replace(pvistor));
OK(sub_expr2->preorder_accept(pvistor));
OK(sub_expr2->postorder_accept(pvistor));
OK(sub_expr2->postorder_replace(pvistor));
_OB_LOG(INFO, "\nsub_expr------\n%s", buf);
ObOpRawExpr op_expr(bin_expr1, sub_expr1, T_OP_IN);
op_expr.set_param_expr(bin_expr1);
op_expr.set_param_exprs(bin_expr1, sub_expr1);
op_expr.set_param_exprs(bin_expr1, sub_expr1, NULL);
op_expr.clear_child();
OK(op_expr.set_param_expr(bin_expr1));
op_expr.clear_child();
OK(op_expr.set_param_exprs(bin_expr1, sub_expr1));
op_expr.clear_child();
OK(op_expr.set_param_exprs(bin_expr1, sub_expr1, NULL));
op_expr.reset();
ObRawExprPrintVisitor op_vistor(*op_expr1);
char op_buf[1024];
op_vistor.to_string(op_buf, sizeof(op_buf));
OK(op_expr1->postorder_replace(op_vistor));
ASSERT_FALSE(op_expr1->same_as(*op_expr2));
(*op_expr1).assign(*op_expr2);
ASSERT_TRUE(op_expr1->same_as(*op_expr2));
sub_expr1->reset();
bin_expr1->reset();
get_raw_expr("case name when 'sam' then 'yong' when 'lee' then 'handsome' else 'good' end", raw_expr1, canon_expr);
get_raw_expr("case when 1>0 then 'true' else 'false' end", raw_expr2, canon_expr);
ObCaseOpRawExpr* case_expr1 = dynamic_cast<ObCaseOpRawExpr*>(raw_expr1);
ObCaseOpRawExpr* case_expr2 = dynamic_cast<ObCaseOpRawExpr*>(raw_expr2);
OK(ObRawExprUtils::copy_expr(expr_factory_, raw_expr1, copy_expr, false, true, true));
OK(case_expr1->preorder_accept(pvistor));
OK(case_expr1->postorder_accept(pvistor));
case_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
ASSERT_FALSE(case_expr1->same_as(*case_expr2));
(*case_expr1).assign(*case_expr2);
ASSERT_TRUE(case_expr1->same_as(*case_expr2));
ObRawExprPrintVisitor case_vistor(*case_expr1);
char case_buf[1024];
case_vistor.to_string(case_buf, sizeof(case_buf));
OK(case_expr1->postorder_replace(case_vistor));
case_expr1->reset();
case_expr2->reset();
_OB_LOG(INFO, "\ncase_expr------\n%s", buf);
get_raw_expr("count(*)", raw_expr1, canon_expr);
get_raw_expr("max(c1)", raw_expr2, canon_expr);
ObAggFunRawExpr* agg_expr1 = dynamic_cast<ObAggFunRawExpr*>(raw_expr1);
ObAggFunRawExpr* agg_expr2 = dynamic_cast<ObAggFunRawExpr*>(raw_expr2);
_OB_LOG(INFO, "\nstr_buf------\n%s", str_buf);
ObRawExprPrintVisitor agg_vistor(*agg_expr1);
char agg_buf[1024];
agg_vistor.to_string(agg_buf, sizeof(agg_buf));
OK(agg_expr1->preorder_accept(pvistor));
OK(agg_expr1->postorder_accept(pvistor));
OK(agg_expr1->postorder_replace(agg_vistor));
_OB_LOG(INFO, "\nagg_buf--post_replace----\n%s", agg_buf);
ASSERT_FALSE(agg_expr1->same_as(*agg_expr2));
(*agg_expr1).assign(*agg_expr2);
ASSERT_TRUE(agg_expr1->same_as(*agg_expr2));
agg_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
agg_expr1->reset();
get_raw_expr("charset(\"test\")", raw_expr1, canon_expr);
get_raw_expr("now()", raw_expr2, canon_expr);
ObSysFunRawExpr* sys_expr1 = dynamic_cast<ObSysFunRawExpr*>(raw_expr1);
ObSysFunRawExpr* sys_expr2 = dynamic_cast<ObSysFunRawExpr*>(raw_expr2);
sys_expr1->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
sys_expr2->get_name_internal(str_buf, BUF_LEN, pos, EXPLAIN_EXTENDED);
ObRawExprPrintVisitor sys_vistor(*sys_expr1);
char sys_buf[1024];
sys_vistor.to_string(sys_buf, sizeof(sys_buf));
OK(sys_expr1->preorder_accept(pvistor));
OK(sys_expr1->postorder_accept(pvistor));
OK(sys_expr1->postorder_replace(sys_vistor));
ASSERT_FALSE(sys_expr1->same_as(*sys_expr2));
(*sys_expr1).assign(*sys_expr2);
ASSERT_TRUE(sys_expr1->same_as(*sys_expr2));
sys_expr1->reset();
sys_expr2->reset();
_OB_LOG(INFO, "\n---------\n%s", buf);
_OB_LOG(INFO, "\n-----get_name_intrenal------\n%s", str_buf);
}
TEST_F(TestRawExpr, special_test)
{
static const char* test_file = "./expr/test_raw_op_expr.test";
static const char* tmp_file = "./expr/test_raw_op_expr.tmp";
static const char* result_file = "./expr/test_raw_op_expr.result";
std::ifstream if_tests(test_file);
ASSERT_TRUE(if_tests.is_open());
std::string line;
const char* json_expr = NULL;
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
int64_t case_id = 0;
while (std::getline(if_tests, line)) {
of_result << '[' << case_id++ << "] " << line << std::endl;
resolver(line.c_str(), json_expr);
of_result << json_expr << std::endl;
}
of_result.close();
// verify results
fprintf(stderr, "If tests failed, use `diff %s %s' to see the differences. \n", result_file, tmp_file);
is_equal_content(tmp_file, result_file);
}
} // namespace test
int main(int argc, char** argv)
{
::testing::InitGoogleTest(&argc, argv);
init_sql_factories();
test::parse_cmd_line_param(argc, argv, test::clp);
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink