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

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

658
unittest/pl/test_pl_basic.cpp Normal file
View File

@ -0,0 +1,658 @@
/**
* 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 PL
#include <gtest/gtest.h>
#include "test_mock_pl_stmt.h"
#include "share/config/ob_server_config.h"
#include "sql/ob_sql_init.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "observer/ob_server.h"
#include "test_pl_utils.h"
using namespace oceanbase;
using namespace oceanbase::common;
using namespace oceanbase::sql;
using namespace oceanbase::pl;
using namespace oceanbase::share;
using namespace observer;
using namespace llvm;
using namespace test;
#define CG_AND_EXECUTE \
ObPLFunction func(allocator_); \
ObPLCodeGenerator cg(func.get_allocator(), func.get_expressions(), func.get_helper(), func.get_di_helper()); \
ObPLExecState pl(exec_ctx.get_allocator(), exec_ctx, func, result, status, recursion_ctx, false); \
ObPhysicalPlanCtx *phy_plan_ctx = exec_ctx.get_physical_plan_ctx(); \
ObExprOperatorCtx **expr_op_ctx_store = exec_ctx.get_expr_op_ctx_store(); \
uint64_t expr_op_size = exec_ctx.get_expr_op_size(); \
exec_ctx.set_physical_plan_ctx(&pl.get_physical_plan_ctx()); \
if (OB_FAIL(recursion_ctx.init(&exec_ctx))) { \
LOG_WARN("fail to init recursion context", K(ret));\
}\
if (OB_SUCC(ret) && func.get_expr_op_size() > 0) { \
exec_ctx.set_expr_op_ctx_store(NULL); \
exec_ctx.set_expr_op_size(0); \
if (OB_FAIL(exec_ctx.init_expr_op(func.get_expr_op_size()))) { \
SQL_LOG(WARN, "failed to init expr op", K(ret)); \
} \
} \
if (OB_SUCC(ret)) { \
if (OB_FAIL(pl.init(&params))) { \
LOG_WARN("failed to init pl", K(ret)); \
} else if (OB_FAIL(pl.execute())) { \
LOG_WARN("failed to execute pl", K(ret)); \
} else { \
for (int64_t i = 0; OB_SUCC(ret) && i < func.get_arg_count(); ++i) { \
if (func.get_out_args().has_member(i)) { \
params.at(i) = pl.get_params().at(i); \
} \
} \
} \
} \
if (OB_SUCC(ret)) { \
exec_ctx.set_physical_plan_ctx(phy_plan_ctx); \
if (func.get_expr_op_size() > 0) { \
exec_ctx.get_allocator().free(exec_ctx.get_expr_op_ctx_store()); \
exec_ctx.set_expr_op_ctx_store(expr_op_ctx_store); \
exec_ctx.set_expr_op_size(expr_op_size); \
} \
}
#define DEFINE_PL_EXEC_CTX \
sql::ObExecContext exec_ctx(allocator_); \
exec_ctx.set_my_session(&session_info_); \
exec_ctx.set_sql_proxy(OBSERVER.get_gctx().sql_proxy_); \
common::ObArray<common::ObObjParam> params; \
ObObj result; \
int status = OB_SUCCESS; \
ObPLExecRecursionCtx recursion_ctx; \
ObPLExecCtx ctx(&allocator_, &exec_ctx, &params, &result, &status, &recursion_ctx);
class ObPLBasicTest : public TestPLUtils, public ::testing::Test
{
public:
ObPLBasicTest() {}
virtual ~ObPLBasicTest() {}
virtual void SetUp() { init(); }
virtual void TearDown() {}
virtual void init() { TestPLUtils::init(); }
public:
// data members
};
TEST_F(ObPLBasicTest, test_declare)
{
int ret = OB_SUCCESS;
//构造FunctionAST
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObNullType);
func_ast.set_ret_type(res_type); //无返回值
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareVarStmt *var_stmt = static_cast<ObPLDeclareVarStmt*>(stmt_service.make_stmt(PL_VAR, block));
var_stmt->add_index(0);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_label_table(&func_ast.get_label_table());
block->get_namespace().set_type_table(&func_ast.get_user_type_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
block->get_namespace().set_cursor_table(&func_ast.get_cursor_table());
block->get_namespace().set_exprs(&func_ast.get_exprs());
// ObPLExternalNS external_ns(NULL);
block->get_namespace().set_external_ns(NULL/*&external_ns*/);
func_ast.set_body(block);
//构造符号表
ObPLDataType var1;
ObDataType obj_type;
ObObjMeta obj_meta;
obj_meta.set_int();
obj_type.set_meta_type(obj_meta);
var1.set_data_type(obj_type);
block->get_namespace().add_symbol(ObString("a"), var1);
//构造执行环境
DEFINE_PL_EXEC_CTX
CG_AND_EXECUTE
}
TEST_F(ObPLBasicTest, test_assign)
{
int ret = OB_SUCCESS;
//构造表达式
ObRawExprFactory expr_factory(allocator_);
ObRawExpr *expr = NULL;
ObConstRawExpr *left_const = NULL;
ObConstRawExpr *right_const = NULL;
ObRawExpr *left_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, left_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (FALSE_IT(left_expr = static_cast<ObRawExpr*>(left_const))) {
} else if (OB_FAIL(ObRawExprUtils::create_param_expr(expr_factory, 0, left_expr))) { //symbol table idx: 0
LOG_WARN("failed to create param expr", K(ret));
} else if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObInt32Type, 100, right_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (ObRawExprUtils::create_double_op_expr(expr_factory, NULL, T_OP_ADD, expr, left_expr, right_const)) {
LOG_WARN("failed to create double expr", K(ret));
} else { /*do nothing*/ }
ObConstRawExpr *into_const = NULL;
ObRawExpr *into_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, into_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (FALSE_IT(into_expr = static_cast<ObRawExpr*>(into_const))) {
} else if (OB_FAIL(ObRawExprUtils::create_param_expr(expr_factory, 1, into_expr))) { //symbol table idx: 1
LOG_WARN("failed to create param expr", K(ret));
} else { /*do nothing*/ }
ObConstRawExpr *default_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, default_expr)) {
LOG_WARN("failed to build const expr", K(ret));
}
ObConstRawExpr *return_const = NULL;
ObRawExpr *return_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, return_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (FALSE_IT(return_expr = static_cast<ObRawExpr*>(return_const))) {
} else if (OB_FAIL(ObRawExprUtils::create_param_expr(expr_factory, 1, return_expr))) { //symbol table idx: 2
LOG_WARN("failed to create param expr", K(ret));
} else { /*do nothing*/ }
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObIntType);
func_ast.set_ret_type(res_type);
ObDataType arg1;
arg1.set_int();
func_ast.add_argument(ObString("test_func_arg1"), arg1);
func_ast.add_expr(expr); //expr table idx: 0
func_ast.add_expr(return_expr); //expr table idx: 1
func_ast.add_expr(default_expr); //expr table idx: 2
func_ast.add_expr(into_expr); //expr table idx: 3
//构造变量
ObPLDataType pl_arg1;
pl_arg1.set_data_type(arg1);
ObPLDataType var1;
var1.set_data_type(arg1);
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareVarStmt *var_stmt = static_cast<ObPLDeclareVarStmt*>(stmt_service.make_stmt(PL_VAR, block));
ObPLAssignStmt *assign_stmt = static_cast<ObPLAssignStmt*>(stmt_service.make_stmt(PL_ASSIGN, block));
ObPLReturnStmt *return_stmt = static_cast<ObPLReturnStmt*>(stmt_service.make_stmt(PL_RETURN, block));
var_stmt->add_index(1);
assign_stmt->set_into(3);
assign_stmt->set_value(0);
return_stmt->set_ret(1);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_label_table(&func_ast.get_label_table());
block->get_namespace().set_type_table(&func_ast.get_user_type_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
block->get_namespace().set_cursor_table(&func_ast.get_cursor_table());
block->get_namespace().set_exprs(&func_ast.get_exprs());
// ObPLExternalNS external_ns(NULL);
block->get_namespace().set_external_ns(NULL/*&external_ns*/);
func_ast.set_body(block);
//构造符号表
block->get_namespace().add_symbol(ObString("test_func_arg1"), pl_arg1, NULL);
ObObj value;
value.set_int(42); //声明变量默认值
default_expr->set_value(value);
block->get_namespace().add_symbol(ObString("a"), var1, default_expr);
//构造执行环境
DEFINE_PL_EXEC_CTX
ObObjParam param;
param.set_int(22); //输入参数实际值
params.push_back(param);
param.set_int(42); //声明变量实际值
params.push_back(param);
CG_AND_EXECUTE
}
TEST_F(ObPLBasicTest, test_return)
{
int ret = OB_SUCCESS;
//构造表达式
ObRawExprFactory expr_factory(allocator_);
ObConstRawExpr *return_const = NULL;
ObRawExpr *return_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 77, return_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (FALSE_IT(return_expr = static_cast<ObRawExpr*>(return_const))) {
} else if (OB_FAIL(ObRawExprUtils::create_param_expr(expr_factory, 0, return_expr))) {
LOG_WARN("failed to create param expr", K(ret));
} else { /*do nothing*/ }
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObIntType);
func_ast.set_ret_type(res_type);
func_ast.add_expr(return_expr); //expr table idx: 0
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLReturnStmt *return_stmt = static_cast<ObPLReturnStmt*>(stmt_service.make_stmt(PL_RETURN, block));
return_stmt->set_ret(0);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_label_table(&func_ast.get_label_table());
block->get_namespace().set_type_table(&func_ast.get_user_type_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
block->get_namespace().set_cursor_table(&func_ast.get_cursor_table());
block->get_namespace().set_exprs(&func_ast.get_exprs());
// ObPLExternalNS external_ns(NULL);
block->get_namespace().set_external_ns(NULL/*&external_ns*/);
func_ast.set_body(block);
//构造执行环境
DEFINE_PL_EXEC_CTX
ObObjParam param;
param.set_int(22); //输入参数实际值
params.push_back(param);
CG_AND_EXECUTE
}
#if 0
TEST_F(ObPLBasicTest, test_sql)
{
int ret = OB_SUCCESS;
//构造表达式
ObRawExprFactory expr_factory(allocator_);
ObConstRawExpr *return_const = NULL;
ObRawExpr *return_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, return_const)) {
LOG_WARN("failed to build const expr", K(ret));
} else if (FALSE_IT(return_expr = static_cast<ObRawExpr*>(return_const))) {
} else if (OB_FAIL(ObRawExprUtils::create_param_expr(expr_factory, 0, return_expr))) {
LOG_WARN("failed to create param expr", K(ret));
} else { /*do nothing*/ }
ObConstRawExpr *default_expr = NULL;
if (ObRawExprUtils::build_const_int_expr(expr_factory, common::ObIntType, 0, default_expr)) {
LOG_WARN("failed to build const expr", K(ret));
}
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObIntType);
func_ast.set_ret_type(res_type);
func_ast.add_expr(return_expr); //expr table idx: 0
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareVarStmt *var_stmt = static_cast<ObPLDeclareVarStmt*>(stmt_service.make_stmt(PL_VAR, block));
ObPLSqlStmt *sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, block));
ObPLReturnStmt *return_stmt = static_cast<ObPLReturnStmt*>(stmt_service.make_stmt(PL_RETURN, block));
var_stmt->add_index(0);
sql_stmt->set_sql(ObString("select 99 from dual"));
sql_stmt->add_into(0);
return_stmt->set_ret(0);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_label_table(&func_ast.get_label_table());
block->get_namespace().set_type_table(&func_ast.get_user_type_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
block->get_namespace().set_cursor_table(&func_ast.get_cursor_table());
block->get_namespace().set_exprs(&func_ast.get_exprs());
// ObPLExternalNS external_ns(NULL);
block->get_namespace().set_external_ns(NULL/*&external_ns*/);
func_ast.set_body(block);
//构造符号表
ObDataType var1;
var1.set_int();
ObPLDataType pl_var1;
pl_var1.set_data_type(var1);
ObObj value;
value.set_int(42); //声明变量默认值
default_expr->set_value(value);
block->get_namespace().add_symbol(ObString("a"), pl_var1, default_expr);
//构造执行环境
DEFINE_PL_EXEC_CTX
ObObjParam param;
param.set_int(42); //声明变量实际值
params.push_back(param);
CG_AND_EXECUTE
}
#endif
TEST_F(ObPLBasicTest, test_eh_basic)
{
int ret = OB_SUCCESS;
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("p"));
ObDataType res_type;
res_type.set_obj_type(common::ObNullType);
func_ast.set_ret_type(res_type); //无返回值
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareHandlerStmt *cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, block));
ObPLDeclareHandlerStmt::DeclareHandler dh;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc = new(desc)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
ObPLConditionValue value;
value.type_ = ERROR_CODE;
value.error_code_ = 7777;
desc->add_condition(value);
// ObPLExternalNS external_ns(NULL);
ObPLStmtBlock *exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
ObPLDeclareVarStmt *var_stmt = static_cast<ObPLDeclareVarStmt*>(stmt_service.make_stmt(PL_VAR, exception_block));
var_stmt->add_index(0);
desc->set_body(exception_block);
dh.set_desc(desc);
cond_stmt->add_handler(dh);
ObPLSignalStmt *signal_stmt = static_cast<ObPLSignalStmt*>(stmt_service.make_stmt(PL_SIGNAL, block));
signal_stmt->set_cond_type(ERROR_CODE);
signal_stmt->set_error_code(7777);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
func_ast.set_body(block);
ObDataType var1;
var1.set_int();
ObPLDataType pl_var1;
pl_var1.set_data_type(var1);
block->get_namespace().add_symbol(ObString("a"), pl_var1);
//构造执行环境
DEFINE_PL_EXEC_CTX
CG_AND_EXECUTE
}
TEST_F(ObPLBasicTest, test_eh_1)
{
int ret = OB_SUCCESS;
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObNullType);
func_ast.set_ret_type(res_type); //无返回值
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareHandlerStmt *cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, block));
ObPLDeclareHandlerStmt::DeclareHandler dh;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc = new(desc)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
ObPLConditionValue value;
value.type_ = SQL_EXCEPTION;
value.error_code_ = 11111111;
value.sql_state_ = "biu~~~";
value.str_len_ = 6;
desc->add_condition(value);
value.type_ = SQL_STATE;
value.error_code_ = 987654321;
value.sql_state_ = "dangdangdangdang";
value.str_len_ = 16;
desc->add_condition(value);
// ObPLExternalNS external_ns(NULL);
ObPLStmtBlock *exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
ObPLSqlStmt *sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, exception_block));
sql_stmt->set_sql(ObString("select 88 from dual"));
desc->set_body(exception_block);
dh.set_desc(desc);
cond_stmt->add_handler(dh);
ObPLSignalStmt *signal_stmt = static_cast<ObPLSignalStmt*>(stmt_service.make_stmt(PL_SIGNAL, block));
signal_stmt->set_cond_type(SQL_STATE);
signal_stmt->set_error_code(987654321);
signal_stmt->set_sql_state("dangdangdangdang");
signal_stmt->set_str_len(16);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
func_ast.set_body(block);
//构造执行环境
DEFINE_PL_EXEC_CTX
CG_AND_EXECUTE
}
TEST_F(ObPLBasicTest, test_eh_2)
{
int ret = OB_SUCCESS;
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObNullType);
func_ast.set_ret_type(res_type); //无返回值
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareHandlerStmt *cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, block));
ObPLDeclareHandlerStmt::DeclareHandler dh1;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc1 = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc1 = new(desc1)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
ObPLConditionValue value;
value.type_ = SQL_WARNING;
value.error_code_ = 11111111;
value.sql_state_ = "biu~~~";
value.str_len_ = 6;
desc1->add_condition(value);
// ObPLExternalNS external_ns(NULL);
ObPLStmtBlock *exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
ObPLSqlStmt *sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, exception_block));
sql_stmt->set_sql(ObString("select 99 from dual"));
desc1->set_body(exception_block);
dh1.set_desc(desc1);
cond_stmt->add_handler(dh1);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
func_ast.set_body(block);
ObPLStmtBlock *subblock = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
subblock->set_block(block);
block->add_stmt(subblock);
ObPLDeclareHandlerStmt::DeclareHandler dh2;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc2 = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc2 = new(desc2)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, subblock));
value.type_ = NOT_FOUND;
value.error_code_ = 22222222;
value.sql_state_ = "biu~biu~~~";
value.str_len_ = 10;
desc2->add_condition(value);
value.type_ = SQL_STATE;
value.error_code_ = 33333333;
value.sql_state_ = "biu~biu~biu~~~";
value.str_len_ = 14;
desc2->add_condition(value);
value.type_ = SQL_EXCEPTION;
value.error_code_ = 44444444;
value.sql_state_ = "biu~biu~biu~biu~~~";
value.str_len_ = 18;
desc2->add_condition(value);
exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, exception_block));
sql_stmt->set_sql(ObString("select 88 from dual"));
desc2->set_body(exception_block);
dh2.set_desc(desc2);
cond_stmt->add_handler(dh2);
ObPLSignalStmt *signal_stmt = static_cast<ObPLSignalStmt*>(stmt_service.make_stmt(PL_SIGNAL, subblock));
signal_stmt->set_cond_type(SQL_STATE);
signal_stmt->set_error_code(987654321);
signal_stmt->set_sql_state("dangdangdangdang");
signal_stmt->set_str_len(16);
//构造执行环境
DEFINE_PL_EXEC_CTX
CG_AND_EXECUTE
}
TEST_F(ObPLBasicTest, test_eh_3)
{
int ret = OB_SUCCESS;
//构造Function
ObPLFunctionAST func_ast(allocator_);
func_ast.set_name(ObString("test_func"));
ObDataType res_type;
res_type.set_obj_type(common::ObNullType);
func_ast.set_ret_type(res_type); //无返回值
//构造Stmt
TestPLStmtMockService stmt_service(allocator_);
ObPLStmtBlock *block = stmt_service.make_block(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ObPLDeclareHandlerStmt *cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, block));
ObPLDeclareHandlerStmt::DeclareHandler dh1;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc1 = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc1 = new(desc1)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
ObPLConditionValue value;
value.type_ = SQL_STATE;
value.error_code_ = 0;
value.sql_state_ = "42S02";
value.str_len_ = 5;
desc1->add_condition(value);
// ObPLExternalNS external_ns(NULL);
ObPLStmtBlock *exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
ObPLSqlStmt *sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, exception_block));
sql_stmt->set_sql(ObString("select 99 from dual"));
desc1->set_body(exception_block);
dh1.set_desc(desc1);
cond_stmt->add_handler(dh1);
block->get_namespace().set_symbol_table(&func_ast.get_symbol_table());
block->get_namespace().set_condition_table(&func_ast.get_condition_table());
func_ast.set_body(block);
ObPLStmtBlock *subblock = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
subblock->set_block(block);
block->add_stmt(subblock);
ObPLDeclareHandlerStmt::DeclareHandler dh2;
ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc2 = static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
desc2 = new(desc2)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc();
cond_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt_service.make_stmt(PL_HANDLER, subblock));
value.type_ = ERROR_CODE;
value.error_code_ = 1051;
value.sql_state_ = NULL;
desc2->add_condition(value);
exception_block = stmt_service.make_block(&block->get_namespace(),
&func_ast.get_symbol_table(),
&func_ast.get_label_table(),
&func_ast.get_condition_table(),
&func_ast.get_cursor_table(),
&func_ast.get_exprs(),
NULL/*&external_ns*/);
sql_stmt = static_cast<ObPLSqlStmt*>(stmt_service.make_stmt(PL_SQL, exception_block));
sql_stmt->set_sql(ObString("select 88 from dual"));
desc2->set_body(exception_block);
dh2.set_desc(desc2);
cond_stmt->add_handler(dh2);
ObPLSignalStmt *signal_stmt = static_cast<ObPLSignalStmt*>(stmt_service.make_stmt(PL_SIGNAL, subblock));
signal_stmt->set_cond_type(SQL_STATE);
signal_stmt->set_error_code(0);
signal_stmt->set_sql_state("42S02");
signal_stmt->set_str_len(5);
//构造执行环境
DEFINE_PL_EXEC_CTX
CG_AND_EXECUTE
}
int main(int argc, char **argv)
{
OB_LOGGER.set_log_level("WARN");
init_sql_factories();
::testing::InitGoogleTest(&argc,argv);
ObScannerPool::build_instance();
ObIntermResultPool::build_instance();
ObServerOptions opts;
opts.cluster_id_ = 1;
opts.rs_list_ = "127.0.0.1:1";
opts.zone_ = "test1";
opts.data_dir_ = "/tmp";
opts.mysql_port_ = 23000 + getpid() % 1000;
opts.rpc_port_ = 24000 + getpid() % 1000;
system("mkdir -p /tmp/sstable /tmp/clog /tmp/slog");
GCONF.datafile_size = 41943040;
// OBSERVER.init(opts);
int ret = 0;//RUN_ALL_TESTS();
OBSERVER.destroy();
return ret;
}