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

[to #45186814] fix continue handler in mysql pl

Browse Source
This commit is contained in:
obdev
2022-11-02 23:40:43 +00:00
committed by wangzelin.wzl
parent a3f0115fb4
commit 7e5730a2f3
1 changed files with 61 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/pl/ob_pl_resolver.cpp
View File

@ -421,7 +421,12 @@ int ObPLResolver::resolve(const ObStmtNodeTree *parse_tree, ObPLFunctionAST &fun
LOG_WARN("fail to check decalre order", K(ret));
} else if (OB_FAIL(resolve_declare_handler(parse_tree, static_cast<ObPLDeclareHandlerStmt*>(NULL == stmt ? current_block_->get_eh() : stmt), func))) {
LOG_WARN("failed to resolve declare handler stmt", K(parse_tree), K(stmt), K(ret));
} else {
} else if (stmt != NULL && static_cast<ObPLDeclareHandlerStmt*>(stmt)->get_handlers().count() <= 0) {
// continue handler will record into handler_analyzer_,
// so here handlers may null, do not add null handler to current block.
stmt = NULL;
}
if (OB_SUCC(ret)) {
func.set_is_all_sql_stmt(false);
}
}
@ -645,7 +650,7 @@ int ObPLResolver::resolve(const ObStmtNodeTree *parse_tree, ObPLFunctionAST &fun
}
if (OB_SUCC(ret) && handler_analyzer_.in_continue() && NULL != stmt && !NO_EXCEPTION_STMT(stmt->get_type())) {
//如果自己在continue里，那么把栈里的handler都加到block里
// for continue handler, should add handler to every stmt, here, make a new block, consturct new block with handler and stmt.
ObPLStmtBlock *block = NULL;
if (OB_FAIL(make_block(func, current_block_, block))) {
LOG_WARN("failed to make block", K(current_block_), K(ret));
@ -990,10 +995,22 @@ int ObPLResolver::check_declare_order(ObPLStmtType type)
CK(PL_VAR == type || PL_COND == type || PL_HANDLER == type || PL_CURSOR == type);
if (is_oracle_mode()) {
// oracle compatible, do nothing ...
} else if (OB_NOT_NULL(current_block_) && current_block_->get_stmts().count() != 0) {
ObPLStmtType pre_type =
current_block_->get_stmts().at(current_block_->get_stmts().count() - 1)->get_type();
if ((PL_VAR == type || PL_COND == type)
} else {
ObPLStmtType pre_type = INVALID_PL_STMT;
if (OB_NOT_NULL(current_block_) && (current_block_->get_stmts().count() != 0)) {
pre_type =
current_block_->get_stmts().at(current_block_->get_stmts().count() - 1)->get_type();
}
if (handler_analyzer_.get_stack_depth() > 0) {
ObPLDeclareHandlerStmt::DeclareHandler info;
if (OB_FAIL(handler_analyzer_.get_handler(handler_analyzer_.get_stack_depth() - 1, info))) {
LOG_WARN("failed to get last handler", K(ret));
} else if (info.get_level() == current_level_) {
pre_type = PL_HANDLER;
}
}
if (OB_FAIL(ret)) {
} else if ((PL_VAR == type || PL_COND == type)
&& (PL_HANDLER == pre_type || PL_CURSOR == pre_type)) {
ret = OB_ER_SP_VARCOND_AFTER_CURSHNDLR;
LOG_USER_ERROR(OB_ER_SP_VARCOND_AFTER_CURSHNDLR);
@ -5202,15 +5219,16 @@ int ObPLResolver::resolve_declare_handler(const ObStmtNodeTree *parse_tree, ObPL
ret = OB_ERR_NO_CHOICES;
LOG_WARN("no choices may appear with choice OTHERS in an exception handler",
K(ret));
} else if (OB_FAIL(desc->add_condition(value))) {
LOG_WARN("failed to add condition for delcare handler desc", K(ret), K(value));
} else {
desc->add_condition(value);
if (NOT_FOUND == actual_type && !handler_analyzer_.in_notfound()) {
handler_analyzer_.set_notfound(current_level_);
current_block_->set_notfound();
} else if (SQL_WARNING == actual_type && !handler_analyzer_.in_warning()) {
handler_analyzer_.set_warning(current_level_);
current_block_->set_warning();
} else { /*do nothing*/ }
}
}
}
}
@ -5235,17 +5253,19 @@ int ObPLResolver::resolve_declare_handler(const ObStmtNodeTree *parse_tree, ObPL
}
}
if (OB_SUCC(ret)) {
if (OB_SUCC(ret) && !desc->is_continue()) {
ObPLDeclareHandlerStmt::DeclareHandler handler;
handler.set_desc(desc);
OZ (stmt->add_handler(handler));
if (OB_FAIL(stmt->add_handler(handler))) {
LOG_WARN("failed to add handler", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_ISNULL(current_block_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Symbol table is NULL", K(current_block_), K(ret));
} else {
} else if (stmt->get_handlers().count() > 0) {
current_block_->set_eh(stmt);
}
}
@ -12194,7 +12214,7 @@ int ObPLResolver::check_duplicate_condition(const ObPLDeclareHandlerStmt &stmt,
{
int ret = OB_SUCCESS;
dup = false;
for (int64_t i = 0; !dup && i < stmt.get_handlers().count(); ++i) {
for (int64_t i = 0; OB_SUCC(ret) && !dup && i < stmt.get_handlers().count(); ++i) {
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = stmt.get_handler(i).get_desc();
if (OB_ISNULL(desc)) {
ret = OB_ERR_UNEXPECTED;
@ -12210,6 +12230,29 @@ int ObPLResolver::check_duplicate_condition(const ObPLDeclareHandlerStmt &stmt,
}
}
}
for (int64_t i = handler_analyzer_.get_stack_depth() - 1; OB_SUCC(ret) && !dup && i >= 0; --i) {
ObPLDeclareHandlerStmt::DeclareHandler handler;
if (OB_FAIL(handler_analyzer_.get_handler(i, handler))) {
LOG_WARN("failed to get handler from handler analyzer", K(ret), K(i));
} else if (handler.get_level() == current_level_) {
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = handler.get_desc();
if (OB_ISNULL(desc)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Handler desc is NULL", K(ret), K(i), K(handler));
} else if (desc->is_continue()) {
for (int64_t j = 0; !dup && j < desc->get_conditions().count(); ++j) {
if (value.type_ == desc->get_condition(j).type_ &&
value.error_code_ == desc->get_condition(j).error_code_ &&
value.str_len_ == desc->get_condition(j).str_len_ &&
0 == STRNCMP(value.sql_state_, desc->get_condition(j).sql_state_, value.str_len_)) {
dup = true;
}
}
}
} else {
break;
}
}
return ret;
}
@ -12431,7 +12474,12 @@ int ObPLResolver::HandlerAnalyzer::reset_handlers(int64_t level)
int ret = OB_SUCCESS;
for (int64_t i = handler_stack_.count() - 1; OB_SUCC(ret) && i >= 0; --i) {
if (handler_stack_.at(i).get_level() == level) {
handler_stack_.pop_back();
if (i != handler_stack_.count() -1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to reset handlers with level", K(ret), K(level), K(i), K(handler_stack_.at(i)));
} else {
handler_stack_.pop_back();
}
}
}
if (OB_SUCC(ret) && handler_stack_.count() - 1 < top_continue_) {