/**

* 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_PARSER

#include "ob_parser.h"

#include "lib/oblog/ob_log.h"

#include "common/sql_mode/ob_sql_mode_utils.h"

#include "parse_malloc.h"

#include "parse_node.h"

#include "ob_sql_parser.h"

#include "pl/parser/ob_pl_parser.h"

#include "lib/utility/ob_tracepoint.h"

#include "lib/json/ob_json_print_utils.h"

using namespace oceanbase::pl;

using namespace oceanbase::sql;

using namespace oceanbase::common;

ObParser::ObParser(common::ObIAllocator &allocator,

ObSQLMode mode,

ObCharsets4Parser charsets4parser,

QuestionMarkDefNameCtx *ctx)

:allocator_(&allocator),

sql_mode_(mode),

charsets4parser_(charsets4parser),

def_name_ctx_(ctx)

{}

ObParser::~ObParser()

{}

#define ISSPACE(c) ((c) == ' ' || (c) == '\n' || (c) == '\r' || (c) == '\t' || (c) == '\f' || (c) == '\v')

bool ObParser::is_pl_stmt(const ObString &stmt, bool *is_create_func, bool *is_call_procedure)

{

int ret = OB_SUCCESS;

State state = S_START;

State save_state = state;

const char *p = stmt.ptr();

const char *p_start = p;

const char *p_end = p + stmt.length();

bool is_pl = false;

bool is_not_pl = false;

const char *p_normal_start = nullptr;

while (p < p_end && !is_pl && !is_not_pl) {

switch (state) {

case S_START:

case S_CREATE:

case S_DD:

case S_BEGIN:

case S_DROP:

case S_ALTER:

case S_UPDATE: {

if (ISSPACE(*p)) {

p++;

} else {

if ('-' == *p) {

if ((p + 1) < p_end && '-' == *(p + 1)) {

save_state = state;

state = S_COMMENT;

p += 2;

}

} else if ('/' == *p) {

if ((p + 1) < p_end && '*' == *(p + 1)) {

save_state = state;

state = S_C_COMMENT;

p += 2;

}

} else if ('#' == *p && lib::is_mysql_mode()) {

save_state = state;

state = S_COMMENT;

p += 1;

}

if (state != S_COMMENT && state != S_C_COMMENT) {

p_normal_start = p;

save_state = state;

state = S_NORMAL;

p++;

}

}

} break;

case S_COMMENT: {

if (*p == '\n') {

state = save_state;

}

p++;

} break;

case S_C_COMMENT: {

if (*p == '*') {

if ((p + 1 < p_end) && '/' == *(p + 1)) {

state = save_state;

p++;

}

}

p++;

} break;

case S_NORMAL: {

if (ISSPACE(*p) || (p == (p_end - 1))) {

int64_t length = (p - p_normal_start) + (ISSPACE(*p) ? 0 : 1);

ObString normal(length, p_normal_start);

state = transform_normal(

save_state, normal, is_pl, is_not_pl, is_create_func, is_call_procedure);

}

p++;

} break;

default: {

is_not_pl = true;

} break;

}

}

return is_pl;

}

// Check if stmt is explain statement.

// On success, set p_normal_start to first char after explain syntax; on error, set p_normal_start to null.

//

// For example, call is_explain_stmt() with SQL query below would return true,

// and p_normal_start would be set as shown below.

//

// explain update t1 set b=0 where a=1;update t1 set b=0 where a=2;

// ^

// p_normal_start

//

// Note that, when using is_explain_stmt(), we assume given SQL query has no syntax errors.

bool ObParser::is_explain_stmt(const ObString &stmt, const char *&p_normal_start)

{

State state = S_START;

State save_state = state;

const char *p = stmt.ptr();

const char *p_start = p;

const char *p_end = p + stmt.length();

bool is_explain = false;

bool has_error = false;

p_normal_start = nullptr;

int i = 0;

static const char *lower[S_MAX] = { nullptr };

static const char *upper[S_MAX] = { nullptr };

static bool inited = false;

if (!inited) {

lower[S_EXPLAIN] = "explain";

lower[S_EXPLAIN_BASIC] = "basic";

lower[S_EXPLAIN_EXTENDED] = "extended";

lower[S_EXPLAIN_EXTENDED_NOADDR] = "extended_noaddr";

lower[S_EXPLAIN_PARTITIONS] = "partitions";

upper[S_EXPLAIN] = "EXPLAIN";

upper[S_EXPLAIN_BASIC] = "BASIC";

upper[S_EXPLAIN_EXTENDED] = "EXTENDED";

upper[S_EXPLAIN_EXTENDED_NOADDR] = "EXTENDED_NOADDR";

upper[S_EXPLAIN_PARTITIONS] = "PARTITIONS";

inited = true;

}

while (p < p_end && !has_error) {

switch (state) {

case S_START:

case S_EXPLAIN_FORMAT: {

if (ISSPACE(*p)) {

p++;

} else {

if (!is_comment(p, p_end, save_state, state, S_INVALID) && state != S_INVALID) {

if (S_START == state) {

// p is at first key token (e.g. not comments or white spaces),

// move to S_EXPLAIN to check if there is 'explain' keyword

save_state = state;

state = S_EXPLAIN;

} else if (S_EXPLAIN_FORMAT == state) {

if (lower[S_EXPLAIN_BASIC][0] == *p || upper[S_EXPLAIN_BASIC][0] == *p) {

save_state = state;

state = S_EXPLAIN_BASIC;

} else if (lower[S_EXPLAIN_EXTENDED][0] == *p || upper[S_EXPLAIN_EXTENDED][0] == *p) {

save_state = state;

state = S_EXPLAIN_EXTENDED;

} else if (lower[S_EXPLAIN_PARTITIONS][0] == *p || upper[S_EXPLAIN_PARTITIONS][0] == *p) {

save_state = state;

state = S_EXPLAIN_PARTITIONS;

} else {

save_state = state;

state = S_NORMAL;

}

}

}

}

} break;

// since we have assumed SQL has no syntax errors,

// we will always find end tokens (e.g. '\n', '*/') for comments.

case S_COMMENT: {

if (*p == '\n') {

// end of '--' comments

state = save_state;

}

p++;

} break;

case S_C_COMMENT: {

if (*p == '*') {

if ((p + 1 < p_end) && '/' == *(p + 1)) {

// end of '/**/' comments

state = save_state;

p++;

}

}

p++;

} break;

case S_EXPLAIN:

case S_EXPLAIN_BASIC:

case S_EXPLAIN_EXTENDED:

case S_EXPLAIN_PARTITIONS: {

State next_state = S_NORMAL;

if (S_EXPLAIN == state) {

// after checking 'explain' keyword,

// we should move to S_EXPLAIN_FORMAT to check extra keywords such as 'basic'

next_state = S_EXPLAIN_FORMAT;

} else if (S_EXPLAIN_EXTENDED == state) {

// after checking 'extended' keyword,

// we should move to S_EXPLAIN_EXTENDED_NOADDR to check if 'extended_noaddr' matches

next_state = S_EXPLAIN_EXTENDED_NOADDR;

}

match_state(p,

is_explain,

has_error,

lower,

upper,

i,

save_state,

state,

next_state);

} break;

case S_EXPLAIN_EXTENDED_NOADDR: {

if (i == 0) {

// we have just finished checking 'extended' keyword,

// continue checking only if next letter is '_'

if ('_' == *p) {

i = strlen(lower[S_EXPLAIN_EXTENDED]);

} else {

state = S_NORMAL;

}

} else {

match_state(p,

is_explain,

has_error,

lower,

upper,

i,

save_state,

state,

S_NORMAL);

}

} break;

case S_NORMAL: {

// we have finished checking keywords,

// find start of first non-space and non-comment char

if (ISSPACE(*p)) {

p++;

} else if (!is_comment(p, p_end, save_state, state, S_NORMAL)) {

p_normal_start = p;

p = p_end;

}

} break;

case S_INVALID:

default: {

is_explain = false;

has_error = true;

} break;

}

}

return is_explain && !has_error;

}

// Check if p matches keyword at index i.

// When all letters have matched, set is_explain=true if there hasn't been any errors

// On success, move state to next_state; on error, move state to S_INVALID.

//

// Note that, when using match_state(), we assume index i is valid.

void ObParser::match_state(const char*&p,

bool &is_explain,

bool &has_error,

const char *lower[S_MAX],

const char *upper[S_MAX],

int &i,

State &save_state,

State &state,

State next_state)

{

if (lower[state][i] == *p || upper[state][i] == *p) {

i++;

p++;

if (i == strlen(lower[state])) {

is_explain = !has_error;

save_state = state;

state = next_state;

i = 0;

}

} else {

save_state = state;

state = S_INVALID;

}

}

// Check if comments start at p.

bool ObParser::is_comment(const char *&p,

const char *&p_end,

State &save_state,

State &state,

State error_state)

{

bool found_comment = false;

if ('-' == *p) {

if ((p + 1) < p_end && '-' == *(p + 1)) {

save_state = state;

state = S_COMMENT;

p += 2;

found_comment = true;

} else {

state = error_state;

}

} else if ('/' == *p) {

if ((p + 1) < p_end && '*' == *(p + 1)) {

save_state = state;

state = S_C_COMMENT;

p += 2;

found_comment = true;

} else {

state = error_state;

}

}

return found_comment;

}

ObParser::State ObParser::transform_normal(ObString &normal)

{

State state = S_INVALID;

#define IF(len, s, str) \

if (len == normal.length() && 0 == STRNCASECMP(normal.ptr(), str, len)) { \

state = s; \

}

#define ELSIF(len, s, str) \

else if (len == normal.length() && 0 == STRNCASECMP(normal.ptr(), str, len)) { \

state = s; \

}

#define ELSE() \

else { \

LOG_DEBUG("transform_normal", K(state), K(normal)); \

}

IF(6, S_CREATE, "create")

ELSIF(8, S_FUNCTION, "function")

ELSIF(9, S_PROCEDURE, "procedure")

ELSIF(7, S_PACKAGE, "package")

ELSIF(7, S_TRIGGER, "trigger")

ELSIF(4, S_TYPE, "type")

ELSIF(2, S_OR, "or")

ELSIF(7, S_REPLACE, "replace")

ELSIF(7, S_DEFINER, "definer")

ELSIF(2, S_DO, "do")

ELSIF(2, S_DD, "dd")

ELSIF(5, S_BEGIN, "begin")

ELSIF(7, S_DECLARE, "declare")

ELSIF(2, S_DECLARE, "<<")

ELSIF(4, S_DROP, "drop")

ELSIF(4, S_CALL, "call")

ELSIF(5, S_ALTER, "alter")

ELSIF(6, S_UPDATE, "update")

ELSIF(2, S_OF, "of")

ELSIF(11, S_EDITIONABLE, "editionable")

ELSIF(14, S_EDITIONABLE, "noneditionable")

ELSIF(6, S_SIGNAL, "signal")

ELSIF(8, S_RESIGNAL, "resignal")

ELSIF(5, S_FORCE, "force")

ELSE()

if (S_INVALID == state

&& normal.length() >= 2 && 0 == STRNCASECMP(normal.ptr(), "<<", 2)) {

state = S_DECLARE;

}

if (S_INVALID == state

&& normal.length() >= 7 && 0 == STRNCASECMP(normal.ptr(), "definer", 7)) {

state = S_DEFINER;

}

#undef IF

#undef ELSIF

#undef ELSE

return state;

}

ObParser::State ObParser::transform_normal(

ObParser::State state, ObString &normal, bool &is_pl, bool &is_not_pl,

bool *is_create_func, bool *is_call_procedure)

{

switch (state) {

case S_START: {

State token = transform_normal(normal);

switch (token) {

case S_DO:

case S_DECLARE:

case S_PROCEDURE:

case S_FUNCTION:

case S_PACKAGE:

case S_TRIGGER:

case S_TYPE:

case S_SIGNAL:

case S_RESIGNAL: {

is_pl = true;

} break;

case S_CALL: {

is_not_pl = lib::is_oracle_mode();

is_pl = lib::is_mysql_mode();

if (is_call_procedure != NULL) {

*is_call_procedure = true;

}

} break;

case S_CREATE:

case S_DD:

case S_BEGIN:

case S_DROP:

case S_ALTER:

case S_UPDATE: {

state = token;

} break;

case S_INVALID:

default: {

is_not_pl = true;

} break;

}

} break;

case S_CREATE: {

State token = transform_normal(normal);

switch (token) {

case S_PROCEDURE:

case S_PACKAGE:

case S_TRIGGER:

case S_TYPE:

case S_DEFINER: {

is_pl = true;

} break;

case S_OR:

case S_REPLACE:

case S_EDITIONABLE:

case S_FORCE: {

// do nothing ...

} break;

case S_FUNCTION: {

is_pl = true;

if (is_create_func != NULL) {

*is_create_func = true;

}

} break;

default: {

is_not_pl = true;

} break;

}

} break;

case S_DD: {

if (S_BEGIN == transform_normal(normal)) {

is_pl = true;

} else {

is_not_pl = true;

}

} break;

case S_BEGIN: {

if ((normal.length() > 0 && ';' == (normal.ptr()[0]))

|| (normal.length() >= 4 && 0 == STRNCASECMP(normal.ptr(), "work", 4))) {

is_not_pl = true;

} else {

is_pl = true;

}

} break;

case S_DROP:

case S_ALTER: {

State token = transform_normal(normal);

if (S_PROCEDURE == token || S_FUNCTION == token

|| S_PACKAGE == token || S_TRIGGER == token || S_TYPE == token) {

is_pl = true;

} else {

is_not_pl = true;

}

} break;

case S_UPDATE: {

if (S_OF == transform_normal(normal)) {

is_pl = true;

} else {

is_not_pl = true;

}

} break;

default: {

is_not_pl = true;

LOG_WARN_RET(common::OB_ERR_UNEXPECTED, "unexpected state", K(state));

} break;

}

return state;

}

bool ObParser::is_single_stmt(const ObString &stmt)

{

int64_t count = 0;

// 去除尾部多余空格，否则 ‘select 1 from dual; ’ 这种会出错

int64_t end_trim_offset = stmt.length();

while (end_trim_offset > 0 && ISSPACE(stmt[end_trim_offset - 1])) {

end_trim_offset--;

}

for (int64_t i = 0; i < end_trim_offset; i++) {

if (';' == stmt[i]) {

count++;

}

}

return (0 == count || (1 == count && stmt[end_trim_offset - 1] == ';'));

}

int ObParser::split_start_with_pl(const ObString &stmt,

ObIArray<ObString> &queries,

ObMPParseStat &parse_stat)

{

int ret = OB_SUCCESS;

int tmp_ret = OB_SUCCESS;

int64_t remain = stmt.length();

ParseResult parse_result;

ParseMode parse_mode = MULTI_MODE;

parse_stat.reset();

// 绕过parser对空查询处理不友好的方法：自己把末尾空格去掉

while (remain > 0 && ISSPACE(stmt[remain - 1])) {

--remain;

}

//去除末尾一个‘\0’, 为与mysql兼容

if (remain > 0 && '\0' == stmt[remain - 1]) {

--remain;

}

//再删除末尾空格

while (remain > 0 && (ISSPACE(stmt[remain - 1]))) {

--remain;

}

// 对于空语句的特殊处理

if (OB_UNLIKELY(0 >= remain)) {

ObString part; // 空串

ret = queries.push_back(part);

}

if (remain > 0 && OB_SUCC(ret) && !parse_stat.parse_fail_) {

ObArenaAllocator allocator(CURRENT_CONTEXT->get_malloc_allocator());

allocator.set_label("PLSplitStmt");

ObIAllocator *bak_allocator = allocator_;

allocator_ = &allocator;

ObString part(remain, stmt.ptr());

if (OB_FAIL(tmp_ret = parse(part, parse_result, parse_mode, false, true))) {

ret = queries.push_back(part);

if (OB_SUCCESS == ret) {

parse_stat.parse_fail_ = true;

parse_stat.fail_query_idx_ = queries.count() - 1;

parse_stat.fail_ret_ = tmp_ret;

}

LOG_WARN("fail parse multi part", K(part), K(stmt), K(ret));

} else {

CK(remain == parse_result.end_col_);

CK(nullptr != bak_allocator);

CK(nullptr != parse_result.result_tree_);

for (int64_t i = 0; OB_SUCC(ret) && i < parse_result.result_tree_->num_child_; ++i) {

int64_t str_len = parse_result.result_tree_->children_[i]->str_len_;

int64_t offset = parse_result.result_tree_->children_[i]->pos_;

ObString query(str_len, stmt.ptr() + offset);

OZ(queries.push_back(query));

}

}

allocator_ = bak_allocator;

}

return ret;

}

// In multi-stmt mode(delimiter #) eg: create t1; create t2; create t3

// in the case of is_ret_first_stmt(false), queries will return the following stmts:

// queries[0]: create t1;

// queries[1]: create t2;

// queries[2]: create t3;

// in the case of is_ret_first_stmt(true) and it will return one element

// queries[0]: create t1;

// Actually, sql executor only executes the first stmt(create t1) and ignore the others

// even though try to execute stmts like 'create t1; create t2; create t3;'

int ObParser::split_multiple_stmt(const ObString &stmt,

ObIArray<ObString> &queries,

ObMPParseStat &parse_stat,

bool is_ret_first_stmt,

bool is_prepare)

{

int ret = OB_SUCCESS;

//对于单条sql的场景，先判断is_single_stmt，然后再判断is_pl_stmt，避免is_pl_stmt字符串比较的开销

if (is_single_stmt(stmt)) {

ObString query(stmt.length(), stmt.ptr());

ret = queries.push_back(query);

} else if (is_pl_stmt(stmt)) {

if (lib::is_mysql_mode()) {

ret = split_start_with_pl(stmt, queries, parse_stat);

} else {

ObString query(stmt.length(), stmt.ptr());

ret = queries.push_back(query);

}

} else {

ParseResult parse_result;

ParseMode parse_mode = MULTI_MODE;

int64_t offset = 0;

int64_t remain = stmt.length();

parse_stat.reset();

// 绕过parser对空查询处理不友好的方法：自己把末尾空格去掉

while (remain > 0 && ISSPACE(stmt[remain - 1])) {

--remain;

}

//去除末尾一个‘\0’, 为与mysql兼容

if (remain > 0 && '\0' == stmt[remain - 1]) {

--remain;

}

//再删除末尾空格

while (remain > 0 && ((ISSPACE(stmt[remain - 1])) ||

(lib::is_mysql_mode() && is_prepare && stmt[remain - 1] == ';'))) {

--remain;

}

// 对于空语句的特殊处理

if (OB_UNLIKELY(0 >= remain)) {

ObString part; // 空串

ret = queries.push_back(part);

}

int tmp_ret = OB_SUCCESS;

bool need_continue = true;

while (remain > 0 && OB_SUCC(ret) && !parse_stat.parse_fail_ && need_continue) {

ObArenaAllocator allocator(CURRENT_CONTEXT->get_malloc_allocator());

allocator.set_label("SplitMultiStmt");

ObIAllocator *bak_allocator = allocator_;

allocator_ = &allocator;

int64_t str_len = 0;

//for save memory allocate in parser, we need try find the single stmt length in advance

//calc the end position of a single sql.

get_single_sql(stmt, offset, remain, str_len);

str_len = str_len == remain ? str_len : str_len + 1;

ObString part(str_len, stmt.ptr() + offset);

ObString remain_part(remain, stmt.ptr() + offset);

//first try parse part str, because it's have less length and need less memory

if (OB_FAIL(tmp_ret = parse(part, parse_result, parse_mode, false, true))) {

//if parser part str failed, then try parse all remain part, avoid parse many times

//bug:

tmp_ret = OB_SUCCESS;

tmp_ret = parse(remain_part, parse_result, parse_mode);

}

if (OB_SUCC(tmp_ret)) {

int32_t single_stmt_length = parse_result.end_col_;

if (is_ret_first_stmt) {

ObString first_query(single_stmt_length, stmt.ptr());

ret = queries.push_back(first_query);

need_continue = false; // only return the first stmt, so ignore the remaining stmts

} else {

if (is_pl_stmt(part) && lib::is_mysql_mode()) {

ObString query(remain, stmt.ptr() + offset);

allocator_ = bak_allocator;

ret = split_start_with_pl(query, queries, parse_stat);

need_continue = false;

} else {

ObString query(single_stmt_length,stmt.ptr() + offset);

ret = queries.push_back(query);

}

}

remain -= parse_result.end_col_;

offset += parse_result.end_col_;

if (remain < 0 || offset > stmt.length()) {

LOG_ERROR("split_multiple_stmt data error",

K(remain), K(offset), K(stmt.length()), K(ret));

}

} else {

ObString query(static_cast<int32_t>(remain), stmt.ptr() + offset);

ret = queries.push_back(query);

if (OB_SUCCESS == ret) {

parse_stat.parse_fail_ = true;

parse_stat.fail_query_idx_ = queries.count() - 1;

parse_stat.fail_ret_ = tmp_ret;

}

LOG_WARN("fail parse multi part", K(part), K(stmt), K(ret));

}

allocator_ = bak_allocator;

}

}

return ret;

}

int ObParser::check_is_insert(common::ObIArray<common::ObString> &queries, bool &is_ins)

{

int ret = OB_SUCCESS;

is_ins = false;

bool is_replace = false;

if (queries.count() < 1) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("queries is unexpected", K(ret));

} else if (queries.count() > 1) {

// query个数大于1，multi query 不做优化

} else {

ObString &sql_str = queries.at(0);

is_ins = (sql_str.length() > 6 && 0 == STRNCASECMP(sql_str.ptr(), "insert", 6));

is_replace = (sql_str.length() > 7 && 0 == STRNCASECMP(sql_str.ptr(), "replace", 7));

is_ins = is_ins | is_replace;

}

return ret;

}

int ObParser::reconstruct_insert_sql(const common::ObString &stmt,

common::ObIArray<common::ObString> &queries,

common::ObIArray<common::ObString> &ins_queries,

bool &can_batch_exec)

{

int ret = OB_SUCCESS;

int tmp_ret = OB_SUCCESS;

ParseResult parse_result;

ParseMode parse_mode = INS_MULTI_VALUES;

int64_t strlen = stmt.length();

bool is_insert = false;

can_batch_exec = false;

if (OB_FAIL(check_is_insert(queries, is_insert))) {

LOG_WARN("fail to check is insert", K(ret));

}

if (OB_SUCC(ret) && is_insert) {

ObArenaAllocator allocator(CURRENT_CONTEXT->get_malloc_allocator());

allocator.set_label("InsMultiValOpt");

ObIAllocator *bak_allocator = allocator_;

allocator_ = &allocator;

if (OB_FAIL(parse(stmt, parse_result, parse_mode, false, true))) {

// if parser SQL failed，then we won't rewrite it and keep it as it is

LOG_WARN("failed to parser insert sql", K(ret), K(stmt));

} else if (parse_result.ins_multi_value_res_->values_count_ == 1) {

// only one set of values，not need rewrite

} else if (OB_ISNULL(bak_allocator)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("bak_allocator is null", K(ret));

} else {

// restore the allocator

allocator_ = bak_allocator;

LOG_DEBUG("after do reconstruct sql, result is",

K(parse_result.ins_multi_value_res_->on_duplicate_pos_),

K(parse_result.ins_multi_value_res_->values_col_),

K(parse_result.ins_multi_value_res_->values_count_),

K(stmt));

bool is_on_duplicate = (parse_result.ins_multi_value_res_->on_duplicate_pos_ > 0);

int64_t on_duplicate_length = stmt.length() - parse_result.ins_multi_value_res_->on_duplicate_pos_;

for (ParenthesesOffset *current_obj = parse_result.ins_multi_value_res_->ref_parentheses_;

OB_SUCC(ret) && NULL != current_obj;

current_obj = current_obj->next_) {

char *new_sql_buf = NULL;

int64_t pos = 0;

const int64_t shared_length = parse_result.ins_multi_value_res_->values_col_;

// The reason for +1 here is

// insert into t1 values(1,1),(2,2);

// left_parentheses_ is the offset of the first left parenthesis，

// right_parentheses_ Is the offset after the end of the last matched closing bracket

// right_parentheses_ - left_parentheses_，not contain the length of the left parenthesis, so the length + 1

const int64_t values_length = current_obj->right_parentheses_ - current_obj->left_parentheses_ + 1;

// The reason for here + 1 is to add a delimiter;

int64_t final_length = shared_length + values_length + 1; // 这个+1的原因是 为了后边的';'

if (is_on_duplicate) {

// for the on_duplicate_key clause of insert_up

final_length = final_length + on_duplicate_length;

}

if (OB_ISNULL(new_sql_buf = static_cast<char*>(allocator_->alloc(final_length)))) {

ret = OB_ALLOCATE_MEMORY_FAILED;

LOG_WARN("fail to alloc memory", K(ret), K(final_length));

} else if (OB_FAIL(databuff_memcpy(new_sql_buf, final_length, pos, shared_length, stmt.ptr()))) {

LOG_WARN("failed to deep copy new sql", K(ret), K(final_length), K(shared_length), K(pos), K(stmt));

} else if (OB_FAIL(databuff_memcpy(new_sql_buf, final_length, pos, values_length, (stmt.ptr() + (current_obj->left_parentheses_ - 1))))) {

LOG_WARN("failed to deep copy member list buf", K(ret), K(final_length), K(pos), K(stmt), K(values_length));

} else if (is_on_duplicate && OB_FAIL(databuff_memcpy(new_sql_buf,

final_length,

pos,

on_duplicate_length,

stmt.ptr() + parse_result.ins_multi_value_res_->on_duplicate_pos_))) {

} else {

new_sql_buf[final_length - 1] = ';';

ObString part(final_length, new_sql_buf);

if (OB_FAIL(ins_queries.push_back(part))) {

LOG_WARN("fail to push back query str", K(ret), K(part));

} else {

LOG_DEBUG("after rebuild multi_query sql is", K(part));

}

}

}

}

if (OB_SUCC(ret) && ins_queries.count() > 1) {

can_batch_exec = true;

}

// No matter whether the previous operation is successful or not,

// the allocator should be restored here

allocator_ = bak_allocator;

}

LOG_TRACE("after reconstruct ins sql", K(ret), K(can_batch_exec), K(ins_queries), K(stmt));

return OB_SUCCESS;

}

int32_t ObParser::get_well_formed_errlen(const ObCharsetInfo *charset_info,

const char *err_ptr,

int32_t err_len)

{

static const int32_t max_error_length = 80;

err_len = std::min(err_len, max_error_length);

int32_t res_len = err_len;

//issue/29914471

if (OB_NOT_NULL(charset_info)) {

int err = 0;

int32_t well_formed_errlen =

static_cast<int32_t>(charset_info->cset->well_formed_len(charset_info,

err_ptr,

err_ptr + err_len,

UINT64_MAX,

&err));

LOG_DEBUG("check well_formed_errlen", K(well_formed_errlen), K(err_len),

K(err), K(charset_info->name));

if (err != 0

&& well_formed_errlen < err_len

&& err_len - well_formed_errlen < charset_info->mbmaxlen) {

res_len = well_formed_errlen;

}

}

return res_len;

}

// avoid separating sql by semicolons in quotes or comment.

void ObParser::get_single_sql(const common::ObString &stmt, int64_t offset, int64_t remain, int64_t &str_len) {

/* following two flags are used to mark wether we are in comment, if in comment, ';' can't be used to split sql*/

// in -- comment

bool comment_flag = false;

// in /*! comment */ or /* comment */

bool c_comment_flag = false;

/* following three flags are used to mark wether we are in quotes.*/

// in '', single quotes

bool sq_flag = false;

// in "", double quotes

bool dq_flag = false;

// in ``, backticks.

bool bt_flag = false;

bool is_escape = false;

bool in_comment = false;

bool in_string = false;

while (str_len < remain && (in_comment || (stmt[str_len + offset] != ';'))) {

if (!in_comment && !in_string) {

if (str_len + 1 >= remain) {

} else if ((stmt[str_len + offset] == '-' && stmt[str_len + offset + 1] == '-') || stmt[str_len + offset + 1] == '#') {

comment_flag = true;

} else if (stmt[str_len + offset] == '/' && stmt[str_len + offset + 1] == '*') {

c_comment_flag = true;

} else if (stmt[str_len + offset] == '\'') {

sq_flag = true;

} else if (stmt[str_len + offset] == '"') {

dq_flag = true;

} else if (stmt[str_len + offset] == '`') {

bt_flag = true;

}

} else if (in_comment) {

if (comment_flag) {

if (stmt[str_len + offset] == '\r' || stmt[str_len + offset] == '\n') {

comment_flag = false;

}

} else if (c_comment_flag) {

if (str_len + 1 >= remain) {

} else if (stmt[str_len + offset] == '*' && (str_len + 1 < remain) && stmt[str_len + offset + 1] == '/') {

c_comment_flag = false;

}

}

} else if (in_string) {

if (str_len + 1 >= remain) {

} else if (lib::is_mysql_mode() && !bt_flag && stmt[str_len + offset] == '\\') {

// in mysql mode, handle the escape char in '' and ""

++ str_len;

} else if (sq_flag) {

if (stmt[str_len + offset] == '\'') {

sq_flag = false;

}

} else if (dq_flag) {

if (stmt[str_len + offset] == '"') {

dq_flag = false;

}

} else if (bt_flag) {

if (stmt[str_len + offset] == '`') {

bt_flag = false;

}

}

}

++ str_len;

// update states.

in_comment = comment_flag || c_comment_flag;

in_string = sq_flag || bt_flag || dq_flag;

}

}

int ObParser::parse_sql(const ObString &stmt,

ParseResult &parse_result,

const bool no_throw_parser_error)

{

int ret = OB_SUCCESS;

ObSQLParser sql_parser(*(ObIAllocator*)(parse_result.malloc_pool_), sql_mode_);

ObString stmt_str = stmt;

if (OB_FAIL(sql_parser.parse(stmt.ptr(), stmt.length(), parse_result))) {

// if is multi_values_parser opt not need retry

if (lib::is_mysql_mode() && !parse_result.is_multi_values_parser_) {

parse_result.enable_compatible_comment_ = false;

parse_result.mysql_compatible_comment_ = false;

if (OB_FAIL(sql_parser.parse(stmt.ptr(), stmt.length(), parse_result))) {

//do nothing.

}

}

#ifdef NDEBUG

if (parse_result.may_contain_sensitive_data_) {

parse_result.contain_sensitive_data_ = true;

stmt_str = ObString(OB_MASKED_STR);

}

#endif

if (!no_throw_parser_error) {

LOG_INFO("failed to parse stmt as sql", K(stmt_str), K(ret));

}

} else if (parse_result.is_dynamic_sql_) {

memmove(parse_result.no_param_sql_ + parse_result.no_param_sql_len_,

parse_result.input_sql_ + parse_result.pl_parse_info_.last_pl_symbol_pos_,

parse_result.input_sql_len_ - parse_result.pl_parse_info_.last_pl_symbol_pos_);

parse_result.no_param_sql_len_

+= parse_result.input_sql_len_ - parse_result.pl_parse_info_.last_pl_symbol_pos_;

} else { /*do nothing*/ }

#ifndef NDEBUG

parse_result.contain_sensitive_data_ = false;

#endif

if (parse_result.is_fp_ || parse_result.is_multi_query_) {

if (OB_FAIL(ret) && !no_throw_parser_error) {

LOG_WARN("failed to fast parameterize", K(stmt_str), K(ret));

}

}

if (OB_SUCC(ret) &&

parse_result.enable_compatible_comment_ &&

parse_result.mysql_compatible_comment_) {

ret = OB_ERR_PARSE_SQL;

LOG_WARN("the sql is invalid", K(ret), K(stmt_str));

}

if (OB_FAIL(ret) && !no_throw_parser_error) {

auto err_charge_sql_mode = lib::is_oracle_mode();

LOG_WARN("failed to parse the statement",

K(stmt_str),

K(parse_result.is_fp_),

K(parse_result.is_multi_query_),

K(parse_result.yyscan_info_),

K(parse_result.result_tree_),

K(parse_result.malloc_pool_),

"message", parse_result.error_msg_,

"start_col", parse_result.start_col_,

"end_col", parse_result.end_col_,

K(parse_result.line_),

K(parse_result.yycolumn_),

K(parse_result.yylineno_),

K(parse_result.extra_errno_),

K(parse_result.is_for_remap_),

K(err_charge_sql_mode),

K(sql_mode_),

K(parse_result.sql_mode_),

K(parse_result.may_bool_value_),

K(ret));

int32_t error_offset = parse_result.start_col_ > 0 ? (parse_result.start_col_ - 1) : 0;

int32_t error_length = stmt.empty() ? 0 : get_well_formed_errlen(parse_result.charset_info_,

stmt.ptr() + error_offset,

stmt.length() - error_offset);

if (OB_ERR_PARSE_SQL == ret) {

LOG_USER_ERROR(OB_ERR_PARSE_SQL, ob_errpkt_strerror(OB_ERR_PARSER_SYNTAX, false),

error_length,

stmt.empty() ? NULL : stmt.ptr() + error_offset,

parse_result.line_ + 1);

} else {

// other errors handle outer side.

}

}

return ret;

}

int ObParser::parse(const ObString &query,

ParseResult &parse_result,

ParseMode parse_mode,