hcq/oceanbase
hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
oceanbase/unittest/sql/resolver/test_resolver.cpp
obdev 2d19a9d8f5 [FEAT MERGE]4_1_sql_feature 
Co-authored-by: leslieyuchen <leslieyuchen@gmail.com>
Co-authored-by: Charles0429 <xiezhenjiang@gmail.com>
Co-authored-by: raywill <hustos@gmail.com>
2023-01-28 16:01:28 +08:00

665 lines
24 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 <iterator>
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/ob_sql_init.h"
#include "sql/ob_select_stmt_printer.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/resolver/dml/ob_insert_stmt.h"
#include "sql/resolver/dml/ob_update_stmt.h"
#include "sql/resolver/dml/ob_delete_stmt.h"
#include "sql/resolver/tcl/ob_start_trans_stmt.h"
#include "sql/resolver/tcl/ob_end_trans_stmt.h"
#include "sql/resolver/dcl/ob_create_user_stmt.h"
#include "sql/resolver/dcl/ob_grant_stmt.h"
#include "sql/resolver/dcl/ob_revoke_stmt.h"
#include "sql/resolver/dcl/ob_drop_user_stmt.h"
#include "sql/resolver/dcl/ob_rename_user_stmt.h"
#include "sql/resolver/dcl/ob_set_password_stmt.h"
#include "sql/ob_sql_define.h"
#include "lib/string/ob_sql_string.h"
#include "../test_sql_utils.h"
#include "sql/optimizer/ob_join_order.h"
using namespace oceanbase::obrpc;
namespace test
{
const char* SQL_DIR = "sql";
const char* RESULT_DIR ="result";
class TestResolver: public TestSqlUtils, public ::testing::Test
{
public:
TestResolver();
virtual ~TestResolver(){}
virtual void SetUp();
virtual void TearDown();
protected:
void do_equal_test();
void do_stmt_copy_test();
void do_padding_test();
void do_expand_view_test();
void do_stmt_tostring_test();
void do_join_order_test();
void input_test_from_cmd();
uint64_t get_next_table_id(const uint64_t user_tenant_id);
bool is_show_sql(const ParseNode &node) const;
static void get_index_name(std::string &str, const ObTableSchema &idx_schema);
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(TestResolver);
};
TestResolver::TestResolver()
{
memcpy(schema_file_path_, "./test_resolver.schema", sizeof("./test_resolver.schema"));
}
void TestResolver::SetUp()
{
init();
}
void TestResolver::TearDown()
{
destroy();
}
bool TestResolver::is_show_sql(const ParseNode &node) const
{
bool ret = false;
switch( node.type_){
case T_SHOW_TABLES:
case T_SHOW_DATABASES:
case T_SHOW_VARIABLES:
case T_SHOW_COLUMNS:
case T_SHOW_SCHEMA:
case T_SHOW_CREATE_TABLE:
case T_SHOW_CREATE_VIEW:
case T_SHOW_TABLE_STATUS:
case T_SHOW_PARAMETERS:
//case T_SHOW_INDEXES:
case T_SHOW_PROCESSLIST:
case T_SHOW_SERVER_STATUS:
case T_SHOW_WARNINGS:
case T_SHOW_RESTORE_PREVIEW:
case T_SHOW_SEQUENCES:
case T_SHOW_GRANTS:{
ret = true;
break;
}
default: {
ret = false;
}
}
return ret;
}
TEST_F(TestResolver, basic_test)
{
//for rongxuan.test input sql in command line
if (clp.test_input_from_cmd){
input_test_from_cmd();
exit(0);
}
const char *postfix[] = {"test","tmp","result"};
int64_t sql_postfix_len = strlen(postfix[0]);
int64_t tmp_postfix_len = strlen(postfix[1]);
int64_t result_postfix_len = strlen(postfix[2]);
char file_name[3][FILE_PATH_LEN];
//construct the file name ./sql/test_resolver_xxx.test sql file
//construct the file name ./result/test_resolver_xxx.tmp tmp result file
//construct the file name ./result/test_resolver_xxx.test correct result file (now is empty)
// int ret = 0;
for(int32_t i = 0; i < clp.file_count; ++i){
if (i > 0) {
destroy();
init();
}
int64_t sql_file_len = strlen(clp.file_names_vector[i]);
snprintf(file_name[0],
strlen(SQL_DIR) + sql_file_len + sql_postfix_len + 4,
"./%s/%s%s",
SQL_DIR,
//clp.file_names[i],
clp.file_names_vector[i],
postfix[0]);
snprintf(file_name[1],
strlen(RESULT_DIR) + sql_file_len + tmp_postfix_len + 4,
"./%s/%s%s",
RESULT_DIR,
//clp.file_names[i],
clp.file_names_vector[i],
postfix[1]);
snprintf(file_name[2],
strlen(RESULT_DIR) + sql_file_len + result_postfix_len + 4,
"./%s/%s%s",
RESULT_DIR,
// clp.file_names[i],
clp.file_names_vector[i],
postfix[2]);
_OB_LOG(INFO, "%s\t%s\t%s\t%s",clp.file_names_vector[i],file_name[0], file_name[1], file_name[2]);
std::ifstream if_sql(file_name[0]);
if (!if_sql.is_open()){
_OB_LOG(ERROR,"file %s not exist!", file_name[0]);
continue;
} else {
fprintf(stdout, "CASE FILE: %s\n", file_name[0]);
}
ASSERT_TRUE(if_sql.is_open());
ObStmt *stmt = NULL;
std::ofstream of_tmp(file_name[1]);
ASSERT_TRUE(of_tmp.is_open()) << file_name[1];
if (!of_tmp.is_open()) {
_OB_LOG(ERROR,"file %s not exist!", file_name[1]);
continue;
}
std::string line;
int64_t case_id = 0;
bool is_print = false;
int64_t expect_error = 0;
char *w;
char *p;
int64_t case_line = 0;
while (std::getline(if_sql, line)) {
++case_line;
if (line.size() <= 0) continue;
if (line.at(0) == '#') continue;
if (strncmp(line.c_str(), "--error", strlen("--error")) == 0) {
p = const_cast<char*>(line.c_str());
w = strsep(&p, " ");
expect_error = atol(p);
continue;
}
if (line.at(0) == '\r' || line.at(0) == '\n' ) continue;
stmt = NULL;
of_tmp << "*************** Case "<< ++case_id << " ***************" << std::endl;
of_tmp << line << std::endl;
_OB_LOG(INFO, "case %ld: query str %s", case_id, line.c_str());
//fprintf(stdout, "case %ld: %s\n", case_id, line.c_str());
ASSERT_NO_FATAL_FAILURE(do_load_sql(line.c_str(),stmt, is_print, TREE_FORMAT, expect_error, case_line));
if (expect_error == 0) {
//ASSERT_FALSE(HasFatalFailure());
if (NULL != stmt) {
of_tmp << CSJ(*stmt) << std::endl;
}
} else {
expect_error = 0;
}
allocator_.reset();
stmt_factory_.destory();
expr_factory_.destory();
}
of_tmp.close();
if_sql.close();
_OB_LOG(INFO, "test %s finished!, total %ld case", clp.file_names_vector[i], case_id);
fprintf(stdout, "FINISHED %s TOTAL %ld\n", clp.file_names_vector[i], case_id);
// verify result
// ObSqlString cmd;
// cmd.assign_fmt("diff -u %s %s", file_name[1], file_name[2]);
// ret = system(cmd.ptr());
// EXPECT_EQ(0, ret) << cmd.ptr() << std::endl;
//std::ifstream if_result(file_name[2]);
//ASSERT_TRUE(if_result.is_open());
//std::istream_iterator<std::string> it_result(if_result);
//std::ifstream if_tmp(file_name[1]);
//ASSERT_TRUE(if_tmp.is_open());
//std::istream_iterator<std::string> it_tmp(if_tmp);
//ASSERT_TRUE(std::equal(it_result, std::istream_iterator<std::string>(), it_tmp));
//if_result.close();
//if_tmp.close();
ASSERT_NO_FATAL_FAILURE(is_equal_content(file_name[1], file_name[2]));
// ret = 0;
UNUSED(w);
}
}
TEST_F(TestResolver, join_order)
{
do_join_order_test();
}
void TestResolver::do_equal_test()
{
//just for equals test
// const char* query_sqls[3] = {
// "select c1,c2 from rongxuan.t1 where c1 > 0 group by c1 having count(c1) > 0 order by c2 desc limit 10",
// "(select c5, c7 from rongxuan.test) union ( select t1.c1, t2.c2 from rongxuan.t1 join rongxuan.t2 on t1.c1 = t2.c1)",
// "select t1.c1,t2.c2,test.c3 from rongxuan.t1 join rongxuan.t2 on t1.c1 =t2.c1 join rongxuan.test on t2.c1 = test.c1"
//
// };
//
// bool is_print = false;
// uint32_t size = sizeof(query_sqls)/sizeof(const char*);
// for(uint32_t i = 0; i < size; ++i) {
// ObStmt *stmt1 = NULL;
// ObStmt *stmt2 = NULL;
// do_resolve(query_sqls[i], stmt1, is_print, JSON_FORMAT, OB_SUCCESS, false);
// OB_ASSERT(stmt1 && (stmt::T_SELECT == stmt1->get_stmt_type()));
// ObSelectStmt *select_stmt1 = static_cast<ObSelectStmt *>(stmt1);
// do_resolve(query_sqls[i], stmt2, is_print, JSON_FORMAT, OB_SUCCESS, false);
// OB_ASSERT(stmt2 && (stmt::T_SELECT == stmt2->get_stmt_type()));
// ObSelectStmt *select_stmt2 = static_cast<ObSelectStmt *>(stmt2);
// //bool result = select_stmt1->equals(*select_stmt2);
// //_OB_LOG(INFO, "Equal Test for %s, ret = %d", query_sqls[i], result);
// //OB_ASSERT(result);
// stmt_factory_.destory();
// expr_factory_.destory();
// }
}
void TestResolver::do_padding_test()
{
ObStmt *stmt = NULL;
const char* query = "update char_t set c2 = 'aa', c3 = concat(c2, '4')";
do_resolve(query, stmt, true, JSON_FORMAT, OB_SUCCESS, false);
OB_LOG(INFO, "START TO BUILD EXPR FOR BINARY COLUMN");
const char* query2 = "update char_t set c6 = 'aa', c7 = concat(c6, '4')";
do_resolve(query2, stmt, true, JSON_FORMAT, OB_SUCCESS, false);
OB_LOG(INFO, "START TO BUILD EXPR FOR char COLUMN");
ObObj obj;
obj.set_varchar("PAD_CHAR_TO_FULL_LENGTH");
ASSERT_TRUE(OB_SUCCESS == session_info_.update_sys_variable_by_name(OB_SV_SQL_MODE, obj));
do_resolve(query, stmt, true, JSON_FORMAT, OB_SUCCESS, false);
}
void TestResolver::do_join_order_test()
{
const char* input_file = "test_skyline.sql";
const char* result_file = "test_skyline.result";
const char* tmp_file = "test_skyline.tmp";
std::ifstream if_sql(input_file);
if (!if_sql.is_open()){
_OB_LOG(ERROR,"file %s not exist!", input_file);
exit(1);
} else {
fprintf(stdout, "CASE FILE: %s\n", input_file);
}
ASSERT_TRUE(if_sql.is_open());
std::ofstream of_tmp(tmp_file);
if (!of_tmp.is_open()) {
_OB_LOG(ERROR, "file %s not exist!", tmp_file);
} else {
fprintf(stdout, "Temp RESULT FILE :%s\n", tmp_file);
}
ASSERT_TRUE(of_tmp.is_open());
std::string line;
int64_t case_id = 0;
while (std::getline(if_sql, line)) {
if (line.size() <= 0) continue;
if (line.at(0) == '#') continue;
if (line.at(0) == '\r' || line.at(0) == '\n' ) continue;
of_tmp << "*************** Case "<< ++case_id << " ***************\n" << std::endl;
of_tmp << line << "\n\n";
ObStmt *stmt = NULL;
do_resolve(line.c_str(), stmt ,true, JSON_FORMAT, OB_SUCCESS, false);
ObDMLStmt *dml_stmt = static_cast<ObDMLStmt*>(stmt);
ASSERT_TRUE(NULL != dml_stmt);
ObIArray<TableItem *> &table_items = dml_stmt->get_table_items();
for (int64_t i = 0; i < table_items.count(); ++i) {
const uint64_t table_id = table_items.at(i)->table_id_;
const uint64_t ref_id = table_items.at(i)->ref_id_;
const ObTableSchema *table_schema = NULL;
OK(schema_guard_.get_table_schema(ref_id, table_schema));
ObSEArray<ObAuxTableMetaInfo, 16> simple_index_infos;
int ret = table_schema->get_simple_index_infos(simple_index_infos, false/*with mv*/);
ASSERT_EQ(ret, OB_SUCCESS);
of_tmp << "table [" << table_schema->get_table_name() << "]" << std::endl;
for (int i = 0; i <= simple_index_infos.count(); ++i) {
const ObTableSchema *idx_schema = NULL;
ObArray<ObRawExpr*> index_keys;
ObArray<ObRawExpr*> ordering;
int64_t match_prefix_count = 0;
if (i == simple_index_infos.count()) {
idx_schema = table_schema;
} else {
OK(schema_guard_.get_table_schema(simple_index_infos.at(i).table_id_, idx_schema));
}
ret = ObOptimizerUtil::generate_rowkey_exprs(dml_stmt,
expr_factory_,
table_id,
*idx_schema,
index_keys,
ordering);
ASSERT_EQ(ret, OB_SUCCESS);
std::string idx_name_with_column;
get_index_name(idx_name_with_column, *idx_schema);
ASSERT_EQ(ret, OB_SUCCESS);
of_tmp <<"\t" << idx_name_with_column << "\n";
ObSEArray<OrderItem, 4> index_ordering;
for (int64_t i = 0; OB_SUCC(ret) && i < index_keys.count(); ++i) {
OrderItem order_item(index_keys.at(i), default_asc_direction());
if (OB_FAIL(index_ordering.push_back(order_item))) {
LOG_WARN("failed to push back order item", K(ret));
}
}
bool group_match = false;
ObSelectStmt *select_stmt = static_cast<ObSelectStmt*>(dml_stmt);
ret = ObOptimizerUtil::is_group_by_match(index_keys, select_stmt,
match_prefix_count, group_match);
ASSERT_EQ(ret, OB_SUCCESS);
of_tmp << "\tis_group_math:" << group_match << "\t\t" << "match count:" << match_prefix_count << "\n";
bool distinct_match = false;
match_prefix_count = 0;
ret = ObOptimizerUtil::is_distinct_match(index_keys, select_stmt,
match_prefix_count, distinct_match);
of_tmp << "\tis_distinct_match:" << distinct_match << "\t" << "match count:" <<match_prefix_count << "\n";
bool orderby_match = false;
match_prefix_count = 0;
int64_t order_size = dml_stmt->get_order_item_size();
SQL_OPT_LOG(WARN, "order size", K(order_size));
ret = ObOptimizerUtil::is_order_by_match(index_ordering, select_stmt,
match_prefix_count, orderby_match);
of_tmp << "\tis_orderby_match:" << orderby_match << "\t" << "match_count:" <<match_prefix_count <<"\n";
bool set_match = false;
match_prefix_count = 0;
if (select_stmt->is_parent_set_distinct()) {
ret = ObOptimizerUtil::is_set_match(index_keys, select_stmt,
match_prefix_count, set_match);
}
of_tmp << "\tis_set_match:" << set_match << "\t" << "match_count:" << match_prefix_count << "\n";
of_tmp << std::endl;
SQL_OPT_LOG(WARN, "sort match prefix", K(group_match), K(match_prefix_count),
K(table_id), K(simple_index_infos.at(i).table_id_), K(idx_schema->get_table_name_str()));
}
of_tmp << "----------------------------------" << std::endl;
}
of_tmp << "\n*************** Case "<< case_id << "(end)***************\n" << std::endl;
}
std::string cmd;
cmd.append("diff -u ").append(tmp_file).append(" ").append(result_file);
ASSERT_EQ(OB_SUCCESS, system(cmd.c_str()));
std::cout << cmd << std::endl;
of_tmp.close();
if_sql.close();
}
void TestResolver::get_index_name(std::string &str, const ObTableSchema &idx_schema)
{
const ObRowkeyInfo &info = idx_schema.get_rowkey_info();
ObString idx_name;
if (idx_schema.is_index_table()) {
idx_schema.get_index_name(idx_name);
} else {
idx_name = idx_schema.get_table_name_str();
}
str.append(idx_name.ptr()).append(" <");
for (int64_t i = 0; i < info.get_size(); ++i) {
uint64_t column_id = info.get_column(i)->column_id_;
str.append(idx_schema.get_column_schema(column_id)->get_column_name());
if (i != info.get_size() -1) {
str.append(", ");
}
}
str.append(">");
}
void TestResolver::do_stmt_copy_test()
{
ObStmt *stmt = NULL;
ObSelectStmt *select_stmt = NULL;
const char* query = NULL;
query = "select /*+ index(t1 idx1) */ t1.c1,t1.c2 from rongxuan.t1, rongxuan.t2 partition(p0)"
" where t1.c1 > 0 and t1.c1 = t1.c2 and t1.c2 = t2.c3 "
" group by t1.c1 having count(t1.c1) > 0 order by t1.c2 desc limit 10";
_OB_LOG(INFO, "Copy Test for %s", query);
do_resolve(query, stmt, false, JSON_FORMAT, OB_SUCCESS, false);
OB_ASSERT(stmt && (stmt::T_SELECT == stmt->get_stmt_type()));
select_stmt = static_cast<ObSelectStmt *>(stmt);
ObSelectStmt dest_stmt;
//test SemiInfo
SemiInfo semi1;
semi1.join_type_ = RIGHT_OUTER_JOIN;
semi1.left_tables_.add_member(1);
semi1.left_tables_.add_member(2);
ASSERT_EQ(OB_SUCCESS, select_stmt->add_semi_info(&semi1));
// test ObStmt deep_copy
ASSERT_EQ(OB_SUCCESS, dest_stmt.assign(*select_stmt));
//ASSERT_TRUE(select_stmt->equals(dest_stmt));
// test part expr
//const ObTableSchema *table_schema = schema_mgr_->get_table_schema(sys_tenant_id_, "rongxuan", "t2", false);
const ObTableSchema *table_schema = NULL;
OK(schema_guard_.get_table_schema(sys_tenant_id_, "rongxuan", "t2", false,table_schema));
ASSERT_TRUE(table_schema);
ASSERT_TRUE(NULL != dest_stmt.get_part_expr(table_schema->get_table_id(), table_schema->get_table_id()));
//test ObStmtHint
ASSERT_EQ(OB_SUCCESS, dest_stmt.check_and_convert_hint(session_info_));
const ObStmtHint &hint = dest_stmt.get_stmt_hint();
ASSERT_TRUE(NULL != hint.get_index_hint(select_stmt->get_table_item(0)->table_id_));
// test partition table
TableItem *part_table = select_stmt->get_table_item_by_id(table_schema->get_table_id());
ASSERT_TRUE(NULL != part_table);
ASSERT_TRUE(!part_table->part_ids_.empty());
// test joined table
query = "select t1.c1,t1.c2, test.c3 from (t1 join t2 on t1.c1 =t2.c1) join (t3 join test on t3.c3 = test.c1) on t1.c2 = test.c2";
do_resolve(query, stmt, false, JSON_FORMAT, OB_SUCCESS, false);
ASSERT_TRUE(stmt && (stmt::T_SELECT == stmt->get_stmt_type()));
select_stmt = static_cast<ObSelectStmt *>(stmt);
JoinedTable *joined_table = select_stmt->get_joined_table(OB_INVALID_ID - 1);
ASSERT_TRUE(NULL != joined_table);
const ObSelectStmt *const_select = select_stmt;
const JoinedTable *const_joined_table = const_select->get_joined_table(OB_INVALID_ID - 1);
ASSERT_TRUE(NULL != const_joined_table);
ASSERT_TRUE(joined_table->same_as(*const_joined_table));
ASSERT_EQ(OB_SUCCESS, dest_stmt.assign(*select_stmt));
// test not strict
ObObj obj;
obj.set_varchar("");
ASSERT_EQ(OB_SUCCESS, session_info_.update_sys_variable_by_name(OB_SV_SQL_MODE, obj));
query = "insert into t4(c1) values (1)";
do_resolve(query, stmt, false, JSON_FORMAT, OB_SUCCESS, false);
}
void TestResolver::do_expand_view_test() {
static const char* test_file = "./sql/expand_view.test";
static const char* tmp_file = "./result/expand_view.tmp";
static const char* result_file = "./result/expand_view.result";
_OB_LOG(INFO, "%s\t%s\t%s", test_file, tmp_file, result_file);
std::ifstream if_sql(test_file);
ASSERT_TRUE(if_sql.is_open());
std::ofstream of_tmp(tmp_file);
ASSERT_TRUE(of_tmp.is_open());
ObStmt *stmt = NULL;
std::string line;
int64_t case_id = 0;
bool is_print = false;
int64_t expect_error = 0;
char *w;
char *p;
while (std::getline(if_sql, line)) {
if (line.size() <= 0) continue;
if (line.at(0) == '#') continue;
if (strncmp(line.c_str(), "--error", strlen("--error")) == 0) {
p = const_cast<char*>(line.c_str());
w = strsep(&p, " ");
expect_error = atol(p);
continue;
}
UNUSED(w);
if (line.at(0) == '\r' || line.at(0) == '\n' ) continue;
// @nijia.nj 为了方便加case，这里硬编码，任何一条语句执行之前都跑一次‘drop view if exists v’
do_load_sql("drop view if exists v", stmt, is_print, TREE_FORMAT, expect_error);
allocator_.reset();
stmt_factory_.destory();
expr_factory_.destory();
stmt = NULL;
do_load_sql(line.c_str(), stmt, is_print, TREE_FORMAT, expect_error);
ASSERT_TRUE(OB_SUCCESS == expect_error);
if (stmt::T_CREATE_TABLE == stmt->get_stmt_type()) {
const ObTableSchema &schema = static_cast<ObCreateTableStmt*>(stmt)->get_create_table_arg().schema_;
if (schema.is_view_table()) {
of_tmp << "*************** Case "<< ++case_id << " ***************" << std::endl;
_OB_LOG(INFO, "case %ld: query str %s", case_id, line.c_str());
const char *view_definition = schema.get_view_schema().get_view_definition();
of_tmp << "before : " << line << std::endl;
of_tmp << "after : create view " << schema.get_table_name() << " as "<< view_definition << std::endl;
}
}
allocator_.reset();
stmt_factory_.destory();
expr_factory_.destory();
}
of_tmp.close();
if_sql.close();
_OB_LOG(INFO, "test expand_view finished!, total %ld case", case_id);
// verify result
// ObSqlString cmd;
// cmd.assign_fmt("diff -u %s %s", tmp_file, result_file);
// system(cmd.ptr());
is_equal_content(tmp_file, result_file);
}
void TestResolver::do_stmt_tostring_test() {
static const char* test_file = "./sql/stmt_tostring.test";
static const char* tmp_file = "./result/stmt_tostring.tmp";
static const char* result_file = "./result/stmt_tostring.result";
_OB_LOG(INFO, "%s\t%s\t%s", test_file, tmp_file, result_file);
std::ifstream if_sql(test_file);
ASSERT_TRUE(if_sql.is_open());
std::ofstream of_tmp(tmp_file);
ASSERT_TRUE(of_tmp.is_open());
ObStmt *stmt = NULL;
std::string line;
int64_t case_id = 0;
bool is_print = false;
int64_t expect_error = 0;
char *w;
char *p;
while (std::getline(if_sql, line)) {
if (line.size() <= 0) continue;
if (line.at(0) == '#') continue;
if (strncmp(line.c_str(), "--error", strlen("--error")) == 0) {
p = const_cast<char*>(line.c_str());
w = strsep(&p, " ");
expect_error = atol(p);
continue;
}
UNUSED(w);
if (line.at(0) == '\r' || line.at(0) == '\n' ) continue;
stmt = NULL;
do_load_sql(line.c_str(), stmt, is_print, TREE_FORMAT, expect_error);
ASSERT_TRUE(OB_SUCCESS == expect_error);
ASSERT_TRUE(stmt::T_SELECT == stmt->get_stmt_type());
char buffer[OB_MAX_SQL_LENGTH];
memset(buffer, '\0', OB_MAX_SQL_LENGTH);
int64_t pos = 0;
ObSelectStmtPrinter stmt_printer(buffer, OB_MAX_SQL_LENGTH, &pos,
static_cast<ObSelectStmt*>(stmt), ObObjPrintParams());
stmt_printer.do_print();
buffer[pos] = '\0';
of_tmp << "*************** Case "<< ++case_id << " ***************" << std::endl;
_OB_LOG(INFO, "case %ld: query str %s", case_id, line.c_str());
of_tmp << "before : " << line << std::endl;
of_tmp << "after : " << buffer << std::endl;
allocator_.reset();
stmt_factory_.destory();
expr_factory_.destory();
}
of_tmp.close();
if_sql.close();
_OB_LOG(INFO, "test stmt to sqlstring finished!, total %ld case", case_id);
// verify result
// ObSqlString cmd;
// cmd.assign_fmt("diff -u %s %s", tmp_file, result_file);
// system(cmd.ptr());
is_equal_content(tmp_file, result_file);
}
void TestResolver::input_test_from_cmd(){
std::ifstream if_schema(schema_file_path_);
ASSERT_TRUE(if_schema.is_open());
std::string line;
std::string schema_sql;
while (std::getline(if_schema, line)){
schema_sql += "|\t";
schema_sql += line;
schema_sql += '\n';
}
if_schema.close();
ObStmt *stmt = NULL;
bool is_print = true;
const char * line_separator = "-------------------------------------------------------------";
while(true){
std::cout << line_separator << std::endl;
std::cout << "|\t SQL in test_resolver.schema" << std::endl;
std::cout << line_separator << std::endl;
std::cout << schema_sql;
std::cout << line_separator << std::endl;
std::string sql;
std::cout << "Please Input SQL: \n>";
if (getline(std::cin, sql)){
std::cout << line_separator << std::endl;
stmt = NULL;
std::cout << "SQL=>" << sql << std::endl;
std::cout << line_separator << std::endl;
do_load_sql(sql.c_str(), stmt, is_print, TREE_FORMAT);
// std::cout << CSJ(*stmt) << std::endl;
}
allocator_.reset();
stmt_factory_.destory();
expr_factory_.destory();
}
//test_resolver->TearDown();
}
}//end of namespace test
int main(int argc, char **argv)
{
test::clp.test_input_from_cmd = false;
test::clp.print_schema_detail_info = false;
test::clp.record_test_result =false;
//argc = 1;
system("rm -rf test_resolver.log");
OB_LOGGER.set_log_level("INFO");
OB_LOGGER.set_file_name("test_resolver.log", true);
::testing::InitGoogleTest(&argc,argv);
test::parse_cmd_line_param(argc, argv, test::clp);
init_sql_factories();
std::cout<<"clp:record_test_result:::"<<test::clp.record_test_result<<std::endl;
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink