hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[FEAT MERGE]patch sql compat feature to 431

Browse Source
This commit is contained in:
SevenJ-swj
2024-04-15 16:07:24 +00:00
committed by ob-robot
parent 71c32f94b0
commit 6423e587c1
177 changed files with 16669 additions and 1854 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
unittest/sql/parser/test_parser.cpp
View File

@ -40,6 +40,9 @@ protected:
void print_parse_outline(const char *query_str, std::ofstream &of_result, int64_t expect_error = OB_SUCCESS);
void do_filter_hint(const char *query_str, std::ofstream &of_result, int64_t expect_error = OB_SUCCESS);
bool pretreat_cmd(std::string line, int64_t &expect_error);
void parse_keyword(std::ifstream &if_tests, std::ofstream &of_result, bool is_sql_keyword);
void do_parse_keyword(const char *keyword, std::ofstream &of_result, bool is_reserved, bool is_sql_keyword);
bool non_reserved_keyword_can_not_be_name(const char *keyword, bool is_sql_keyword);
protected:
// data members
ObArenaAllocator allocator_;
@ -262,6 +265,283 @@ TEST_F(TestParser, test_parser_outline)
is_equal_content(tmp_file,result_file);
}
TEST_F(TestParser, test_mysql_sql_keyword)
{
const char* test_file = "../../../../src/sql/parser/sql_parser_mysql_mode.y";
const char* result_file = "./test_mysql_sql_keyword.result";
const char* tmp_file = "./test_mysql_sql_keyword.tmp";
// run tests
std::ifstream if_tests(test_file);
ASSERT_TRUE(if_tests.is_open());
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
test::clp.sql_mode = DEFAULT_MYSQL_MODE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::MYSQL);
ASSERT_NO_FATAL_FAILURE(parse_keyword(if_tests, of_result, true));
of_result.close();
// verify results
is_equal_content(tmp_file,result_file);
}
TEST_F(TestParser, test_mysql_pl_keyword)
{
const char* test_file = "../../../../src/pl/parser/pl_parser_mysql_mode.y";
const char* result_file = "./test_mysql_pl_keyword.result";
const char* tmp_file = "./test_mysql_pl_keyword.tmp";
// run tests
std::ifstream if_tests(test_file);
ASSERT_TRUE(if_tests.is_open());
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
test::clp.sql_mode = DEFAULT_MYSQL_MODE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::MYSQL);
ASSERT_NO_FATAL_FAILURE(parse_keyword(if_tests, of_result, false));
of_result.close();
// verify results
is_equal_content(tmp_file,result_file);
}
TEST_F(TestParser, test_oracle_sql_keyword)
{
const char* test_file = "../../../../close_modules/oracle_parser/sql/parser/sql_parser_oracle_mode.y";
const char* result_file = "./test_oracle_sql_keyword.result";
const char* tmp_file = "./test_oracle_sql_keyword.tmp";
// run tests
std::ifstream if_tests(test_file);
ASSERT_TRUE(if_tests.is_open());
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
test::clp.sql_mode = DEFAULT_ORACLE_MODE | SMO_ORACLE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::ORACLE);
ASSERT_NO_FATAL_FAILURE(parse_keyword(if_tests, of_result, true));
of_result.close();
// verify results
is_equal_content(tmp_file,result_file);
}
TEST_F(TestParser, test_oracle_pl_keyword)
{
const char* test_file = "../../../../close_modules/oracle_pl/pl/parser/pl_parser_oracle_mode.y";
const char* result_file = "./test_oracle_pl_keyword.result";
const char* tmp_file = "./test_oracle_pl_keyword.tmp";
// run tests
std::ifstream if_tests(test_file);
ASSERT_TRUE(if_tests.is_open());
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
test::clp.sql_mode = DEFAULT_ORACLE_MODE | SMO_ORACLE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::ORACLE);
ASSERT_NO_FATAL_FAILURE(parse_keyword(if_tests, of_result, false));
of_result.close();
// verify results
is_equal_content(tmp_file,result_file);
}
void TestParser::parse_keyword(std::ifstream &if_tests, std::ofstream &of_result, bool is_sql_keyword)
{
std::string line;
const char* reserved_keyword_begin = "//-----------------------------reserved keyword begin-----------------------------------------------";
const char* reserved_keyword_end = "//-----------------------------reserved keyword end-------------------------------------------------";
const char* non_reserved_keyword_begin = "//-----------------------------non_reserved keyword begin-------------------------------------------";
const char* non_keyword_end = "//-----------------------------non_reserved keyword end---------------------------------------------";
bool test_reserved_keyword = false;
bool test_non_reserved_keyword = false;
int64_t num_reserved_keyword = 0;
while (std::getline(if_tests, line)) {
if (strncmp(line.c_str(), reserved_keyword_begin, strlen(reserved_keyword_begin)) == 0) {
of_result << "************** Begin Test Reserved Keyword ***************" << std::endl;
test_reserved_keyword = true;
continue;
} else if (strncmp(line.c_str(), reserved_keyword_end, strlen(reserved_keyword_end)) == 0) {
of_result << "************** Total Count of Reserved Keyword:" << num_reserved_keyword <<" ***************" << std::endl;
of_result << "************** End Test Reserved Keyword ***************" << std::endl;
test_reserved_keyword = false;
continue;
} else if (strncmp(line.c_str(), non_reserved_keyword_begin, strlen(non_reserved_keyword_begin)) == 0) {
of_result << "************** Begin Test Non-Reserved Keyword ***************" << std::endl;
test_non_reserved_keyword = true;
continue;
} else if (strncmp(line.c_str(), non_keyword_end, strlen(non_keyword_end)) == 0) {
of_result << "************** End Test Non-Reserved Keyword ***************" << std::endl;
break;
} else if (!test_reserved_keyword && !test_non_reserved_keyword) {
continue;
}
int64_t line_size = strlen(line.c_str());
char *tmp_buf = NULL;
if (NULL == (tmp_buf = static_cast<char*>(allocator_.alloc(line_size + 1)))) {
fprintf(stderr, "failed to alloc memory for: %s\n", line.c_str());
break;
} else {
MEMSET(tmp_buf, '\0', line_size + 1);
int64_t valid_buf_len = 0;
for (int64_t i = 0; i < line_size; ++i) {
if (isspace(line.c_str()[i])) {
if (valid_buf_len > 0 && valid_buf_len <= line_size) {
tmp_buf[valid_buf_len] = '\0';
if ((is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "FILE_KEY") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "BEGIN_KEY") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "END_KEY") == 0)) {
valid_buf_len -= 4;//FILE_KEY ==> FILE、BEGIN_KEY==> DEGIN、END_KEY==> END
tmp_buf[valid_buf_len] = '\0';
} else if ((is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "INITIAL_") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "NULLX") == 0)) {
valid_buf_len -= 1;//INITIAL_ ==> INITIAL、NULLX==>NULL
tmp_buf[valid_buf_len] = '\0';
}
ASSERT_NO_FATAL_FAILURE(do_parse_keyword(tmp_buf, of_result, test_reserved_keyword, is_sql_keyword));
valid_buf_len = 0;
if (test_reserved_keyword) {
++ num_reserved_keyword;
}
}
} else if (line.c_str()[i] == '/' && i < line_size - 1 && line.c_str()[i + 1] == '*') {
i = i + 2;
while (i < line_size) {
if (line.c_str()[i] == '*' && i < line_size - 1 && line.c_str()[i + 1] == '/') {
i = i + 2;
break;
}
++ i;
}
} else if (valid_buf_len < line_size) {
tmp_buf[valid_buf_len++] = line.c_str()[i];
}
}
if (valid_buf_len > 0 && valid_buf_len <= line_size) {
tmp_buf[valid_buf_len] = '\0';
if ((is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "FILE_KEY") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "BEGIN_KEY") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "END_KEY") == 0)) {
valid_buf_len -= 4;//FILE_KEY ==> FILE、BEGIN_KEY==> DEGIN、END_KEY==> END
tmp_buf[valid_buf_len] = '\0';
} else if ((is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "INITIAL_") == 0) ||
(!is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(tmp_buf, "NULLX") == 0)) {
valid_buf_len -= 1;//INITIAL_ ==> INITIAL、NULLX==>NULL
tmp_buf[valid_buf_len] = '\0';
}
ASSERT_NO_FATAL_FAILURE(do_parse_keyword(tmp_buf, of_result, test_reserved_keyword, is_sql_keyword));
valid_buf_len = 0;
if (test_reserved_keyword) {
++ num_reserved_keyword;
}
}
}
}
}
//reserved keyword test: create table table_name(column_name int);
//non_reserved keyword test: create table table_name(column_name int)
// select 1 alias_name from t1 alias_name;
void TestParser::do_parse_keyword(const char *keyword, std::ofstream &of_result, bool is_reserved, bool is_sql_keyword)
{
char *buf = NULL;
int64_t buf_len = strlen(keyword) * 2 + 1024;
if (NULL == (buf = static_cast<char*>(allocator_.alloc(buf_len)))) {
fprintf(stderr, "failed to alloc memory for: %s\n", keyword);
} else if (is_sql_keyword) {
sprintf(buf, "create table %s(%s int);", keyword, keyword);
if (is_reserved) {
of_result << "Reserved Keyword: "<< keyword << std::endl;
of_result << "Test Table Name and Column Name Sql:" << buf << std::endl;
}
} else if (test::clp.sql_mode & SMO_ORACLE) {
sprintf(buf, "create type %s as table of varchar2(1);", keyword);
if (is_reserved) {
of_result << "Reserved Keyword: "<< keyword << std::endl;
of_result << "Test PL type name Sql:" << buf << std::endl;
}
} else {
sprintf(buf, "create procedure %s () select 1;", keyword);
if (is_reserved) {
of_result << "Reserved Keyword: "<< keyword << std::endl;
of_result << "Test PL procedure name Sql:" << buf << std::endl;
}
}
ObString query = ObString::make_string(buf);
int ret = OB_SUCCESS;
_OB_LOG(INFO, "test keyword to be name: %s", buf);
ObSQLMode mode = test::clp.sql_mode;
ObParser parser(allocator_, mode);
ParseResult parse_result;
ret = parser.parse(query, parse_result);
if ((is_reserved && ret != 0) ||
(!is_reserved && ret == 0)) {
ret = OB_SUCCESS;
} else if (!is_reserved && is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(keyword, "CONSTRAINT") == 0) {
ret = OB_SUCCESS;
} else if ((is_reserved && !is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(keyword, "EXISTS") == 0) ||
(is_reserved && !is_sql_keyword && (test::clp.sql_mode & SMO_ORACLE) && strcmp(keyword, "SET") == 0)) {
ret = OB_SUCCESS;
} else if (!is_reserved && !is_sql_keyword && non_reserved_keyword_can_not_be_name(keyword, is_sql_keyword)) {
ret = OB_SUCCESS;
} else {
fprintf(stderr, "test keyword to be name failed:%s\n", buf);
}
ASSERT_EQ(OB_SUCCESS, -ret);
if (!is_reserved && is_sql_keyword) {
sprintf(buf, "select 1 %s from t1 %s;", keyword, keyword);
query = ObString::make_string(buf);
_OB_LOG(INFO, "test keyword to alias name: %s", buf);
ret = parser.parse(query, parse_result);
if (ret != 0) {
if (non_reserved_keyword_can_not_be_name(keyword, is_sql_keyword)) {
ret = 0;
} else {
fprintf(stderr, "test keyword to alias name failed:%s\n", buf);
}
}
}
ASSERT_EQ(OB_SUCCESS, -ret);
parser.free_result(parse_result);
}
bool TestParser::non_reserved_keyword_can_not_be_name(const char *keyword, bool is_sql_keyword)
{
bool ret = false;
if (is_sql_keyword) {
if (test::clp.sql_mode & SMO_ORACLE) {
if (strcmp(keyword, "USING") == 0 ||
strcmp(keyword, "BULK") == 0 ||
strcmp(keyword, "COLLATE") == 0 ||
strcmp(keyword, "CROSS") == 0 ||
strcmp(keyword, "FULL") == 0 ||
strcmp(keyword, "INNER") == 0 ||
strcmp(keyword, "JOIN") == 0 ||
strcmp(keyword, "LOG") == 0 ||
strcmp(keyword, "LEFT") == 0 ||
strcmp(keyword, "NATURAL") == 0 ||
strcmp(keyword, "RETURN") == 0 ||
strcmp(keyword, "RIGHT") == 0 ||
strcmp(keyword, "RETURNING") == 0) {
ret = true;
}
} else if (strcmp(keyword, "EXCEPT") == 0 ||
strcmp(keyword, "INTERSECT") == 0 ||
strcmp(keyword, "MINUS") == 0 ||
strcmp(keyword, "MEMBER") == 0 ||
strcmp(keyword, "SOUNDS") == 0 ||
strcmp(keyword, "WINDOW") == 0) {
ret = true;
}
} else {
if (test::clp.sql_mode & SMO_ORACLE) {
if (strcmp(keyword, "CHARACTER") == 0 ||
strcmp(keyword, "CONSTANT") == 0 ||
strcmp(keyword, "DATE") == 0 ||
strcmp(keyword, "FLOAT") == 0 ||
strcmp(keyword, "LOOP") == 0 ||
strcmp(keyword, "NUMBER") == 0 ||
strcmp(keyword, "RAW") == 0 ||
strcmp(keyword, "REAL") == 0 ||
strcmp(keyword, "VARCHAR") == 0 ||
strcmp(keyword, "VARCHAR2") == 0) {
ret = true;
}
}
}
return ret;
}
void TestParser::do_parse(const char *query_str, std::ofstream &of_result, int64_t expect_error) {
ObSQLMode mode = test::clp.sql_mode;
ObParser parser(allocator_, mode);
@ -327,9 +607,11 @@ bool TestParser::pretreat_cmd(std::string line, int64_t &expect_error)
if (strncmp(p, "oracle", strlen("oracle")) == 0) {
OB_LOG(INFO, "switch parser sql_mode to oracle");
test::clp.sql_mode = DEFAULT_ORACLE_MODE | SMO_ORACLE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::ORACLE);
} else if (strncmp(p, "mysql", strlen("mysql")) == 0) {
OB_LOG(INFO, "switch parser sql_mode to mysql");
test::clp.sql_mode = DEFAULT_MYSQL_MODE;
set_compat_mode(oceanbase::lib::Worker::CompatMode::MYSQL);
}
skip_cmd = true;
UNUSED(w);