2
* Copyright (c) 2021 OceanBase
3
* OceanBase CE is licensed under Mulan PubL v2.
4
* You can use this software according to the terms and conditions of the Mulan PubL v2.
5
* You may obtain a copy of Mulan PubL v2 at:
6
* http://license.coscl.org.cn/MulanPubL-2.0
7
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
* See the Mulan PubL v2 for more details.
13
#define USING_LOG_PREFIX PL
15
#include "ob_pl_code_generator.h"
16
#include "ob_pl_type.h"
17
#include "ob_pl_compile.h"
18
#include "ob_pl_package.h"
19
#include "lib/string/ob_sql_string.h"
20
#include "common/ob_smart_call.h"
21
#include "sql/resolver/expr/ob_raw_expr_util.h"
22
#include "sql/resolver/expr/ob_raw_expr.h"
23
#include "sql/code_generator/ob_expr_generator_impl.h"
24
#include "lib/hash/ob_hashmap.h"
25
#include "parser/parse_stmt_item_type.h"
29
using namespace common;
35
int ObPLCodeGenerateVisitor::generate(const ObPLStmt &s)
38
OZ (generator_.restart_cg_when_goto_dest(s));
43
int ObPLCodeGenerator::generate_check_autonomos(const ObPLStmt &s)
46
if (NULL == get_current().get_v()) {48
} else if (lib::is_oracle_mode()) {49
OZ (get_helper().set_insert_point(get_current()));
51
ObSEArray<ObLLVMValue, 1> args;
52
if (OB_FAIL(args.push_back(get_vars().at(CTX_IDX)))) { //PL的执行环境53
LOG_WARN("push_back error", K(ret));56
if (OB_FAIL(get_helper().create_call(ObString("spi_check_autonomous_trans"), get_spi_service().spi_check_autonomous_trans_, args, ret_err))) {57
LOG_WARN("failed to create call", K(ret));58
} else if (OB_FAIL(check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {59
LOG_WARN("failed to check success", K(ret));67
int ObPLCodeGenerateVisitor::visit(const ObPLStmtBlock &s)
70
if (NULL == generator_.get_current().get_v()) {72
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {73
LOG_WARN("failed to set insert point", K(ret));74
} else if (OB_FAIL(generator_.generate_goto_label(s))) {75
LOG_WARN("failed to generate goto label", K(ret));77
ObLLVMBasicBlock exit;
79
if (OB_FAIL(generator_.get_helper().create_block(ObString("exit_block"), generator_.get_func(), exit))) {80
LOG_WARN("failed to create block", K(s.get_stmts()), K(ret));82
ObLLVMBasicBlock null_start;
83
generator_.set_label(s.get_label(), s.get_level(), null_start, exit);
86
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_stmts().count(); ++i) {87
ObPLStmt *stmt = s.get_stmts().at(i);
88
if (OB_ISNULL(stmt)) {89
ret = OB_ERR_UNEXPECTED;
90
LOG_WARN("stmt in block is NULL", K(i), K(s.get_stmts()), K(ret));91
} else if (OB_FAIL(SMART_CALL(generate(*stmt)))) {92
LOG_WARN("failed to generate", K(i), K(ret));93
} else { /*do nothing*/ }95
if (OB_SUCC(ret) && lib::is_oracle_mode() && s.get_stmts().count() > 0 &&
96
!generator_.get_ast().is_function()) { // function check logic is in returnstmt cg stage97
ObPLStmt *stmt = s.get_stmts().at(s.get_stmts().count() - 1);
98
if ((0 == s.get_level() && NULL != s.get_block() && NULL == s.get_block()->get_block()) ||
99
(1 == s.get_level() && NULL != s.get_block() && NULL != s.get_block()->get_block() &&
100
NULL == s.get_block()->get_block()->get_block())) {101
if (PL_RETURN != stmt->get_type() &&
102
s.get_is_autonomous()) {103
OZ (generator_.generate_check_autonomos(*stmt));
108
if (s.has_eh()) { //如果有eh，跳到eh的exit分支109
if (NULL != generator_.get_current_exception()->exit_.get_v()) {110
if (OB_FAIL(generator_.finish_current(generator_.get_current_exception()->exit_))) {111
LOG_WARN("failed to finish current", K(s.get_stmts()), K(ret));112
} else if (NULL != exit.get_v()) {113
if (generator_.get_current_exception()->exit_.get_v() == generator_.get_exit().get_v()) {115
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current_exception()->exit_))) {116
LOG_WARN("failed to set insert point", K(ret));117
} else if (OB_FAIL(generator_.get_helper().create_br(exit))) {118
LOG_WARN("failed to create br", K(ret));119
} else { /*do nothing*/ }120
} else { /*do nothing*/ }122
if (OB_FAIL(generator_.set_current(NULL == exit.get_v() ? generator_.get_current_exception()->exit_ : exit))) {123
LOG_WARN("failed to set current", K(ret));128
if (OB_FAIL(generator_.reset_exception())) {129
LOG_WARN("failed to reset exception", K(ret));132
} else if (NULL != exit.get_v()) { //如果没有eh，调到BLOCK自己的exit分支133
if (NULL == generator_.get_current().get_v()) {135
} else if (OB_FAIL(generator_.get_helper().create_br(exit))) {136
LOG_WARN("failed to create br", K(ret));139
} else if (OB_FAIL(generator_.set_current(exit))) {140
LOG_WARN("failed to set current", K(ret));141
} else { /*do nothing*/ }142
} else { /*do nothing*/ }144
if (OB_SUCC(ret) && NULL != exit.get_v()) {145
if (OB_FAIL(generator_.reset_label())) {146
LOG_WARN("failed to reset label", K(ret));152
if (OB_SUCC(ret) && NULL != generator_.get_current().get_v()) {153
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_namespace().get_symbols().count(); ++i) {154
const ObPLVar *var = s.get_variable(s.get_namespace().get_symbols().at(i));
155
if (OB_ISNULL(var)) {156
ret = OB_ERR_UNEXPECTED;
157
LOG_WARN("var is NULL", K(i), K(s.get_namespace().get_symbols().at(i)), K(var), K(ret));158
} else if (var->get_type().is_collection_type() && var->get_name().length() != 0) {159
ObSEArray<ObLLVMValue, 2> args;
160
ObLLVMValue int_value;
161
if (s.get_namespace().get_symbols().at(i) < generator_.get_param_size()) {163
} else if (OB_FAIL(args.push_back(generator_.get_vars().at(generator_.CTX_IDX)))) { //PL的执行环境164
LOG_WARN("push_back error", K(ret));165
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_namespace().get_symbols().at(i), int_value))) {166
LOG_WARN("failed to get int64", K(ret));167
} else if (OB_FAIL(args.push_back(int_value))) {168
LOG_WARN("push_back error", K(ret));171
if (OB_FAIL(generator_.get_helper().create_call(ObString("spi_destruct_collection"), generator_.get_spi_service().spi_destruct_collection_, args, ret_err))) {172
LOG_WARN("failed to create call", K(ret));173
} else if (OB_FAIL(generator_.check_success(ret_err, s.get_stmt_id(), s.in_notfound(), s.in_warning()))) {174
LOG_WARN("failed to check success", K(ret));180
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_namespace().get_cursors().count(); ++i) {181
const ObPLCursor *cursor = s.get_cursor(s.get_namespace().get_cursors().at(i));
182
OZ (generator_.generate_handle_ref_cursor(cursor, s, s.in_notfound(), s.in_warning()));
189
int ObPLCodeGenerateVisitor::visit(const ObPLDeclareUserTypeStmt &s)
191
int ret = OB_SUCCESS;
192
if (NULL == generator_.get_current().get_v()) {194
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {195
LOG_WARN("failed to set insert point", K(ret));197
const ObUserDefinedType *user_defined_type = s.get_user_type();
198
if (OB_ISNULL(user_defined_type)) {199
ret = OB_ERR_UNEXPECTED;
200
LOG_WARN("user defined type is null");201
} else if (OB_FAIL(generator_.generate_user_type(*user_defined_type))) {202
LOG_WARN("failed to generate user type", K(user_defined_type->get_type()));203
} else { /*do nothing*/ }208
int ObPLCodeGenerateVisitor::visit(const ObPLDeclareVarStmt &s)
210
int ret = OB_SUCCESS;
211
if (NULL == generator_.get_current().get_v()) {214
OZ (generator_.get_helper().set_insert_point(generator_.get_current()));
215
OZ (generator_.set_debug_location(s));
217
if (OB_SUCC(ret) && OB_NOT_NULL(generator_.get_current().get_v())) {220
bool is_complex_type_var = false;
221
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_index().count(); ++i) {222
const ObPLVar *var = s.get_var(i);
223
CK (OB_NOT_NULL(var));
225
if (var->get_type().is_obj_type()) {226
OZ (var->get_type().generate_construct(generator_, *s.get_namespace(), value, &s));
227
OX (generator_.get_vars().at(s.get_index(i) + generator_.USER_ARG_OFFSET) = value);
228
} else { // Record和Collection的内存不在栈上申请, 统一在Allocator中申请, 执行结束后统一释放229
ObSEArray<ObLLVMValue, 3> args;
230
ObLLVMValue var_idx, init_value, var_value, extend_value;
232
ObLLVMValue var_type, type_id;
233
ObLLVMValue null_int;
234
int64_t init_size = 0;
235
is_complex_type_var = true;
237
CK (OB_NOT_NULL(s.get_namespace()));
238
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
239
OZ (generator_.get_helper().get_int8(var->get_type().get_type(), var_type));
240
OZ (args.push_back(var_type));
241
OZ (generator_.get_helper().get_int64(var->get_type().get_user_type_id(), type_id));
242
OZ (args.push_back(type_id));
243
OZ (generator_.get_helper().get_int64(s.get_index(i), var_idx));
244
OZ (args.push_back(var_idx));
245
OZ (s.get_namespace()->get_size(PL_TYPE_INIT_SIZE, var->get_type(), init_size));
246
OZ (generator_.get_helper().get_int32(init_size, init_value));
247
OZ (args.push_back(init_value));
248
OZ (generator_.generate_null_pointer(ObIntType, null_int));
249
OZ (args.push_back(null_int));
250
OZ (generator_.get_helper().create_call(ObString("spi_alloc_complex_var"),251
generator_.get_spi_service().spi_alloc_complex_var_,
254
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
255
s.get_block()->in_notfound(),
256
s.get_block()->in_warning()));
257
// Step 2: 初始化类型内容, 如Collection的rowsize,element type等
258
if (OB_SUCC(ret) && !var->get_type().is_opaque_type()) {259
OZ (generator_.extract_objparam_from_context(
260
generator_.get_vars().at(generator_.CTX_IDX),
263
OZ (generator_.extract_extend_from_objparam(var_value, var->get_type(), extend_value));
264
OZ (var->get_type().generate_construct(generator_, *s.get_namespace(),
270
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
271
OZ (generator_.get_helper().create_ptr_to_int(ObString("cast_pointer_to_int"), extend_value, int_type, tmp));272
OZ (generator_.generate_debug(ObString("print new construct"), tmp));276
// Step 3: 默认值是构造函数,调用构造函数的初始化
278
&& var->get_type().is_collection_type()
279
&& PL_CONSTRUCT_COLLECTION == s.get_default()) {280
ObLLVMValue package_id;
282
OZ (generator_.get_helper().get_int64(OB_INVALID_ID, package_id));
283
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
284
OZ (args.push_back(package_id));
285
OZ (args.push_back(var_value));
286
OZ (generator_.get_helper().create_call(ObString("spi_construct_collection"), generator_.get_spi_service().spi_construct_collection_, args, ret_err));287
OZ (generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
294
&& OB_INVALID_INDEX != s.get_default()
295
&& PL_CONSTRUCT_COLLECTION != s.get_default()) {296
ObLLVMValue p_result_obj;
297
OZ (generator_.generate_expr(s.get_default(),
299
is_complex_type_var ? OB_INVALID_ID : s.get_index(0),
301
CK (OB_NOT_NULL(s.get_default_expr()));
304
CK (OB_NOT_NULL(s.get_var(0)));
305
OZ (generator_.generate_check_not_null(s, s.get_var(0)->is_not_null(), p_result_obj));
309
if (OB_FAIL(generator_.extract_datum_from_objparam(p_result_obj, s.get_default_expr()->get_data_type(), result))) {310
LOG_WARN("failed to extract_datum_from_objparam", K(ret));312
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_index().count(); ++i) {313
const ObPLVar *var = s.get_var(i);
314
CK (OB_NOT_NULL(var));
315
// 将默认值存储到paramstore, 第0个变量已经在generate_expr处理过了
316
if (OB_SUCC(ret) && (is_complex_type_var || 0 != i)) {317
ObLLVMValue into_meta_p, ori_meta_p, ori_meta;
318
ObLLVMValue into_accuracy_p, ori_accuracy_p, ori_accuracy;
319
ObLLVMValue into_obj, dest_datum;
320
OZ (generator_.extract_objparam_from_context(generator_.get_vars().at(generator_.CTX_IDX), s.get_index(i), into_obj));
321
if (var->get_type().is_obj_type()) {322
OZ (generator_.extract_datum_ptr_from_objparam(into_obj, s.get_var(i)->get_type().get_obj_type(), dest_datum));
323
OZ (generator_.get_helper().create_store(result, generator_.get_vars().at(s.get_index(i) + generator_.USER_ARG_OFFSET)));
324
OZ (generator_.get_helper().create_store(result, dest_datum));
326
ObLLVMValue allocator, src_datum;
327
const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(s.get_default_expr());
328
OZ (generator_.generate_null(ObIntType, allocator));
329
CK (NULL != s.get_symbol_table());
331
} else if (T_NULL == s.get_default_expr()->get_expr_type() ||
332
(T_QUESTIONMARK == const_expr->get_expr_type() &&
333
0 == s.get_symbol_table()->get_symbol(const_expr->get_value().get_unknown())->get_name().case_compare(ObPLResolver::ANONYMOUS_ARG) &&
334
NULL != s.get_symbol_table()->get_symbol(const_expr->get_value().get_unknown())->get_pl_data_type().get_data_type() &&
335
ObNullType == s.get_symbol_table()->get_symbol(const_expr->get_value().get_unknown())->get_pl_data_type().get_data_type()->get_obj_type())) {337
* allocator可以是null，因为这儿只是修改原复杂类型的属性信息
338
* 对于record来说把内部的元素初始化成一个null，
339
* 对于collection来说把count改为-1标记为未初始化状态
341
OZ (generator_.extract_extend_from_objparam(into_obj,
344
OZ (var->get_type().generate_assign_with_null(generator_,
349
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, src_datum));
350
OZ (generator_.extract_obobj_ptr_from_objparam(into_obj, dest_datum));
351
OZ (var->get_type().generate_copy(generator_, *s.get_namespace(),
352
allocator, src_datum, dest_datum,
353
s.get_block()->in_notfound(),
354
s.get_block()->in_warning(),
356
OZ (generator_.extract_meta_ptr_from_objparam(p_result_obj, ori_meta_p));
357
OZ (generator_.extract_meta_ptr_from_objparam(into_obj, into_meta_p));
358
OZ (generator_.get_helper().create_load(ObString("load_meta"),359
ori_meta_p, ori_meta));
360
OZ (generator_.get_helper().create_store(ori_meta, into_meta_p));
361
OZ (generator_.extract_accuracy_ptr_from_objparam(p_result_obj, ori_accuracy_p));
362
OZ (generator_.extract_accuracy_ptr_from_objparam(into_obj, into_accuracy_p));
363
OZ (generator_.get_helper().create_load(ObString("load_accuracy"),364
ori_accuracy_p, ori_accuracy));
365
OZ (generator_.get_helper().create_store(ori_accuracy, into_accuracy_p));
373
if (lib::is_mysql_mode()) {375
ObSEArray<ObLLVMValue, 1> args;
376
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
377
OZ (generator_.get_helper().create_call(ObString("spi_clear_diagnostic_area"),378
generator_.get_spi_service().spi_clear_diagnostic_area_,
381
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
382
s.get_block()->in_notfound(),
383
s.get_block()->in_warning()));
389
/***************************************************************************************/
390
/* 注意：以下是内存排列有关的代码，修改这里一定要十分理解各种数据类型在LLVM端和SQL端的内存排列和生命周期。
392
***************************************************************************************/
393
int ObPLCodeGenerateVisitor::visit(const ObPLAssignStmt &s)
395
int ret = OB_SUCCESS;
396
if (NULL == generator_.get_current().get_v()) {398
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {399
LOG_WARN("failed to set insert point", K(ret));400
} else if (OB_FAIL(generator_.set_debug_location(s))) {401
LOG_WARN("failed to set debug location", K(ret));402
} else if (s.get_into().count() != s.get_value().count()) {403
ret = OB_ERR_UNEXPECTED;
404
LOG_WARN("into exprs not equal to value exprs", K(ret), K(s.get_into().count()), K(s.get_value().count()));405
} else if (OB_FAIL(generator_.generate_goto_label(s))) {406
LOG_WARN("failed to generate goto label", K(ret));409
OZ (generator_.get_helper().stack_save(stack));
410
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_into().count(); ++i) {411
const ObRawExpr *into_expr = s.get_into_expr(i);
412
const ObRawExpr *value_expr = NULL;
413
if (OB_ISNULL(into_expr)) {414
ret = OB_ERR_UNEXPECTED;
415
LOG_WARN("a assign stmt must has expr", K(s), K(into_expr), K(ret));417
int64_t result_idx = OB_INVALID_INDEX;
418
if (into_expr->is_const_raw_expr()) {419
const ObConstRawExpr* const_expr = static_cast<const ObConstRawExpr*>(into_expr);
420
if (const_expr->get_value().is_unknown()) {421
const ObPLVar *var = NULL;
422
int64_t idx = const_expr->get_value().get_unknown();
423
CK (OB_NOT_NULL(var = s.get_variable(idx)));
425
const ObPLDataType &into_type = var->get_type();
426
if (!into_type.is_collection_type() && !into_type.is_record_type()) {431
ret = OB_ERR_UNEXPECTED;
432
LOG_WARN("Unexpected const expr", K(const_expr->get_value()), K(ret));437
ObLLVMValue p_result_obj;
438
ObObjAccessIdx::AccessType alloc_scop = ObObjAccessIdx::IS_INVALID;
439
uint64_t package_id = OB_INVALID_ID;
440
uint64_t var_idx = OB_INVALID_ID;
441
ObLLVMValue allocator;
442
jit::ObLLVMValue src_datum;
443
jit::ObLLVMValue dest_datum;
444
const ObPLBlockNS *ns = s.get_namespace();
446
ret = OB_ERR_UNEXPECTED;
447
LOG_WARN("Assign stmt must have a valid namespace", K(ret));448
} else if (PL_CONSTRUCT_COLLECTION == s.get_value_index(i)) {449
ObPLDataType final_type;
450
CK (into_expr->is_obj_access_expr());
451
OZ (static_cast<const ObObjAccessRawExpr*>(into_expr)->get_final_type(final_type));
452
CK (final_type.is_collection_type());
454
value_expr = s.get_value_expr(i);
455
if (OB_FAIL(generator_.generate_expr(s.get_value_index(i), s, result_idx,
457
LOG_WARN("failed to generate calc_expr func", K(ret));459
if (lib::is_mysql_mode()) {461
ObSEArray<ObLLVMValue, 1> args;
462
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
463
OZ (generator_.get_helper().create_call(ObString("spi_clear_diagnostic_area"),464
generator_.get_spi_service().spi_clear_diagnostic_area_,
467
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
468
s.get_block()->in_notfound(),
469
s.get_block()->in_warning()));
473
} else if (OB_FAIL(ObObjAccessIdx::datum_need_copy(into_expr, value_expr, alloc_scop))) {474
LOG_WARN("failed to check if datum_need_copy", K(*into_expr), K(*value_expr), K(ret));475
} else if (ObObjAccessIdx::IS_LOCAL == alloc_scop
476
|| (ObObjAccessIdx::IS_PKG != alloc_scop)) {477
alloc_scop = ObObjAccessIdx::IS_LOCAL;
479
if (OB_SUCC(ret) && ObObjAccessIdx::IS_PKG == alloc_scop) { // 如果是Package变量, 记录下PackageId480
OZ (ObObjAccessIdx::get_package_id(into_expr, package_id, &var_idx));
483
//如果是LOCAL，使用运行时语句级allocator
484
if (ObObjAccessIdx::IS_LOCAL == alloc_scop) {486
* 如果不是Collection，原则上应该进一步向上找到母体Collection的allocator，这样太复杂了，我们放弃这么做，直接用生命周期更长的运行时语句级allocator
487
* 这样的后果是：Collection里的string和number类型数据有的是在NestedTable自己的allocator里，有的不是。
488
* 这其实没有问题，基础数据类型不会占用过多内存，而且语句级内存最终会释放，不会泄漏。
490
if (OB_FAIL(generator_.extract_allocator_from_context(generator_.get_vars().at(generator_.CTX_IDX), allocator))) {491
LOG_WARN("Failed to extract_allocator_from_nestedtable", K(*into_expr), K(ret));494
//如果不是LOCAL，那么一定是PKG或者是INVALID，传入NULL allocator;
495
//对于PKG, 由SPI根据package_id从Session上获取对应PackageState上的Allocator;
496
if (OB_FAIL(generator_.generate_null(ObIntType, allocator))) { //初始化一个空的allocator497
LOG_WARN("Failed to extract_allocator_from_nestedtable", K(*into_expr), K(ret));506
* a、原生基本数据类型（不在母结构中的基本数据类型，通过Question Mark访问）：直接找到该变量调用create store，同时需要修改param_store里的值（对于string和number也是如此，指针指向同一份内存）
507
* b、结构中的基本数据类型（在Record或Collection里中的基本数据类型，通过ObjAccess访问）：直接找到该变量的地址调用create store或者调用COPY，不必修改param_store里的值（对于string和number也是如此，指针指向同一份内存）
508
* 注意： 为什么不全部直接调用COPY函数？————其实全部直接调COPY函数代码更简洁，考虑到大多数情况下不需要内存深拷贝，直接create store性能更好。
509
* 这样会造成一种可能性：NestedTable里的string和number类型数据有的是在Collection自己的allocator里，有的不是。————这其实不一定有问题，只要目的端数据的内存生命周期比源端长就可以。
510
* c、集合数据类型（通过ObjAccess访问）：调用该类型的COPY函数，其COPY函数递归进行子域的COPY，不必修改param_store里的值
511
* 注意： NestedTable的数据域的结构内存是自身的allocator_分配的，同时String/Number指针指向的内存也是。
512
* copy之后的Collection同样也是这样。如果有母子关系，Collection的allocator_也相互独立，没有任何所属关系。
514
* PKG变量只能通过通过ObjAccess访问访问，同1.b和1.c
518
if (into_expr->is_const_raw_expr()) { //Local Basic Variables519
const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(into_expr);
520
const ObPLVar *var = NULL;
521
CK (OB_NOT_NULL(const_expr));
522
CK (OB_NOT_NULL(var = s.get_variable(const_expr->get_value().get_unknown())));
523
OZ (generator_.generate_check_not_null(s, var->is_not_null(), p_result_obj));
525
int64_t idx = const_expr->get_value().get_unknown();
526
const ObPLDataType &into_type = var->get_type();
528
ObLLVMValue &var_addr = generator_.get_vars().at(idx + generator_.USER_ARG_OFFSET);
529
if (!into_type.is_collection_type() && !into_type.is_record_type()
530
&& !into_type.is_ref_cursor_type()) {531
OZ (generator_.extract_datum_from_objparam(
532
p_result_obj, into_expr->get_result_type().get_type(), datum));
533
OZ (generator_.get_helper().create_store(datum, var_addr));
536
&& (ObObjAccessIdx::IS_INVALID != alloc_scop
537
|| into_type.is_collection_type()
538
|| into_type.is_record_type()
539
|| into_type.is_ref_cursor_type())) {540
ObLLVMValue into_obj;
541
OZ (generator_.extract_objparam_from_context(generator_.get_vars().at(generator_.CTX_IDX), idx, into_obj));
542
if (into_type.is_obj_type()) {543
OZ (generator_.extract_datum_ptr_from_objparam(
544
into_obj, into_expr->get_result_type().get_type(), dest_datum));
545
OZ (generator_.extract_datum_ptr_from_objparam(
546
p_result_obj, into_expr->get_result_type().get_type(), src_datum));
547
OZ (into_type.generate_copy(generator_,
552
s.get_block()->in_notfound(),
553
s.get_block()->in_warning(),
555
} else if (into_type.is_ref_cursor_type()) {556
OZ (generator_.extract_datum_ptr_from_objparam(
557
p_result_obj, into_expr->get_result_type().get_type(), src_datum));
559
OZ (generator_.generate_debug(ObString("ref cursor data"), src_datum));561
// ref cursor 主要调用ref cursortype的generate copy函数，处理cursor的引用计数
562
OZ (into_type.generate_copy(generator_,
567
s.get_block()->in_notfound(),
568
s.get_block()->in_warning(),
571
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, src_datum));
572
OZ (generator_.extract_obobj_ptr_from_objparam(into_obj, dest_datum));
573
OZ (into_type.generate_copy(generator_,
578
s.get_block()->in_notfound(),
579
s.get_block()->in_warning(),
584
if (OB_SUCC(ret) && generator_.get_param_size() > 0) {585
ObSEArray<ObLLVMValue, 2> args;
587
ObLLVMValue idx_value;
588
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
589
OZ (generator_.get_helper().get_int64(idx, idx_value));
590
OZ (args.push_back(idx_value));
591
OZ (generator_.get_helper().create_call(
592
ObString("spi_process_nocopy_params"),593
generator_.get_spi_service().spi_process_nocopy_params_,
595
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
596
s.get_block()->in_notfound(),
597
s.get_block()->in_warning()));
600
//Sys Var/User Var or PKG Basic Variables or Subprogram Basic Variables
601
} else if (into_expr->is_sys_func_expr()) {602
CK (OB_NOT_NULL(value_expr));
603
OZ (generator_.generate_set_variable(s.get_into_index(i),
605
T_DEFAULT == value_expr->get_expr_type(),
607
s.get_block()->in_notfound(),
608
s.get_block()->in_warning()));
609
} else if (into_expr->is_obj_access_expr()) { //ADT610
ObLLVMValue into_address;
611
ObPLDataType final_type;
612
OZ (generator_.generate_expr(s.get_into_index(i), s, OB_INVALID_INDEX, into_address));
613
if (s.get_value_index(i) != PL_CONSTRUCT_COLLECTION
614
&& ObObjAccessIdx::has_same_collection_access(s.get_value_expr(i), static_cast<const ObObjAccessRawExpr *>(into_expr))) {615
OZ (generator_.generate_expr(s.get_value_index(i), s, result_idx, p_result_obj));
617
OZ (static_cast<const ObObjAccessRawExpr*>(into_expr)->get_final_type(final_type));
618
if (s.get_value_index(i) != PL_CONSTRUCT_COLLECTION) {619
OZ (generator_.generate_check_not_null(s, final_type.get_not_null(), p_result_obj));
623
} else if (final_type.is_obj_type()) {624
OZ (generator_.extract_extend_from_objparam(into_address, final_type, dest_datum));
625
if (ObObjAccessIdx::IS_INVALID != alloc_scop) {627
OZ (generator_.extract_datum_ptr_from_objparam(
629
into_expr->get_result_type().get_type(),
631
OZ (final_type.generate_copy(generator_,
636
s.get_block()->in_notfound(),
637
s.get_block()->in_warning(),
640
ObLLVMValue ori_meta_p, into_meta_p, ori_meta;
641
ObLLVMValue ori_accuracy_p, into_accuracy_p, ori_accuracy;
643
OZ (generator_.extract_datum_from_objparam(
644
p_result_obj, into_expr->get_result_type().get_type(), src_datum));
645
OZ (generator_.get_helper().create_store(src_datum, dest_datum));
646
OZ (generator_.extract_meta_ptr_from_objparam(p_result_obj, ori_meta_p));
647
OZ (generator_.extract_meta_ptr_from_objparam(into_address, into_meta_p));
648
OZ (generator_.get_helper().create_load(ObString("load_meta"), ori_meta_p, ori_meta));649
OZ (generator_.get_helper().create_store(ori_meta, into_meta_p));
650
OZ (generator_.extract_accuracy_ptr_from_objparam(p_result_obj, ori_accuracy_p));
651
OZ (generator_.extract_accuracy_ptr_from_objparam(into_address, into_accuracy_p));
652
OZ (generator_.get_helper().create_load(ObString("load_accuracy"), ori_accuracy_p, ori_accuracy));653
OZ (generator_.get_helper().create_store(ori_accuracy, into_accuracy_p));
659
OZ (generator_.extract_accuracy_ptr_from_objparam(into_address, dest));
660
OZ (generator_.get_helper().get_int64(final_type.get_user_type_id(), src));
661
OZ (generator_.get_helper().create_store(src, dest));
664
} else if (PL_CONSTRUCT_COLLECTION == s.get_value_index(i)){//右值是个数组的构造函数走SPI初始化函数665
ObSEArray<ObLLVMValue, 2> args;
667
ObLLVMValue v_package_id;
668
CK (final_type.is_collection_type());
669
OZ (generator_.get_helper().get_int64(package_id, v_package_id));
670
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
671
OZ (args.push_back(v_package_id));
672
OZ (args.push_back(into_address));
673
OZ (generator_.get_helper().create_call(
674
ObString("spi_construct_collection"),675
generator_.get_spi_service().spi_construct_collection_,
677
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
678
s.get_block()->in_notfound(),
679
s.get_block()->in_warning()));
681
OZ (generator_.extract_extend_from_objparam(into_address,
684
if (OB_SUCC(ret) && final_type.is_collection_type()) { //如果是表，用表自带的allocator685
OZ (generator_.extract_allocator_from_collection(dest_datum,allocator),
688
CK (OB_NOT_NULL(value_expr));
689
// 这儿的dest_datum不一定是一个复杂类型，它可能是一个null
690
// 如 rec := null这样的赋值，这个时候如果extract_extend，结果的类型其实是错误的。
693
} else if (T_NULL == value_expr->get_expr_type()) {694
OZ (final_type.generate_assign_with_null(generator_,
699
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, src_datum));
700
OZ (generator_.extract_obobj_ptr_from_objparam(into_address, dest_datum));
701
OZ (final_type.generate_copy(generator_,
706
s.get_block()->in_notfound(),
707
s.get_block()->in_warning(),
709
OZ (generator_.generate_debug("print dest obj2", dest_datum));710
OZ (generator_.generate_debug("print dest objparam2", into_address));714
if (OB_SUCC(ret) && package_id != OB_INVALID_ID && var_idx != OB_INVALID_ID) {715
OZ (generator_.generate_update_package_changed_info(s, package_id, var_idx));
718
ret = OB_ERR_UNEXPECTED;
719
LOG_WARN("Invalid into expr type", K(*into_expr), K(ret));725
OZ (generator_.get_helper().stack_restore(stack));
730
int ObPLCodeGenerateVisitor::visit(const ObPLIfStmt &s)
732
int ret = OB_SUCCESS;
733
if (NULL == generator_.get_current().get_v()) {735
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {736
LOG_WARN("failed to set insert point", K(ret));737
} else if (OB_FAIL(generator_.generate_goto_label(s))) {738
LOG_WARN("faile to create goto label", K(ret));740
ObLLVMBasicBlock continue_branch;
741
ObLLVMBasicBlock then_branch;
742
ObLLVMBasicBlock else_branch;
743
ObLLVMBasicBlock current = generator_.get_current();
745
if (OB_FAIL(generator_.get_helper().create_block(ObString("continue"), generator_.get_func(), continue_branch))) {746
LOG_WARN("failed to create block", K(ret));747
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("then"), generator_.get_func(), then_branch))) {748
LOG_WARN("failed to create block", K(ret));749
} else if (OB_FAIL(generator_.set_current(then_branch))) {750
LOG_WARN("failed to set current", K(ret));752
if (OB_ISNULL(s.get_then())) {753
ret = OB_ERR_UNEXPECTED;
754
LOG_WARN("a if must have then body", K(s.get_then()), K(ret));755
} else if (OB_FAIL(visit(*s.get_then()))) {756
LOG_WARN("failed to visit then clause", K(ret));758
if (OB_FAIL(generator_.finish_current(continue_branch))) {759
LOG_WARN("failed to finish current", K(ret));761
if (NULL == s.get_else()) {762
else_branch = continue_branch;
764
if (OB_FAIL(generator_.get_helper().create_block(ObString("else"),765
generator_.get_func(),
767
LOG_WARN("failed to create block", K(ret));768
} else if (OB_FAIL(generator_.set_current(else_branch))) {769
LOG_WARN("failed to set current", K(ret));770
} else if (OB_FAIL(visit(*s.get_else()))) {771
LOG_WARN("failed to visit else clause", K(ret));772
} else if (OB_FAIL(generator_.finish_current(continue_branch))) {773
LOG_WARN("failed to finish current", K(ret));774
} else { /*do nothing*/ }780
if (OB_FAIL(generator_.set_current(current))) {781
LOG_WARN("failed to set current", K(ret));782
} else if (OB_FAIL(generator_.set_debug_location(s))) {783
LOG_WARN("failed to set debug location", K(ret));785
const sql::ObRawExpr *expr = s.get_cond_expr();
786
if (OB_ISNULL(expr)) {787
ret = OB_ERR_UNEXPECTED;
788
LOG_WARN("a assign stmt must has expr", K(expr), K(ret));790
ObLLVMValue p_result_obj;
792
ObLLVMValue is_false;
793
if (OB_FAIL(generator_.generate_expr(s.get_cond(), s, OB_INVALID_INDEX,
795
LOG_WARN("failed to generate calc_expr func", K(ret));796
} else if (OB_FAIL(generator_.extract_value_from_objparam(p_result_obj,
797
expr->get_data_type(),
799
LOG_WARN("failed to extract_value_from_objparam", K(ret));800
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(result, FALSE, is_false))) {801
LOG_WARN("failed to create_icmp_eq", K(ret));802
} else if (OB_FAIL(generator_.get_helper().create_cond_br(is_false, else_branch, then_branch))) {803
LOG_WARN("failed to create_cond_br", K(ret));804
} else if (OB_FAIL(generator_.set_current(continue_branch))) {805
LOG_WARN("failed to set current", K(ret));806
} else { /*do nothing*/ }815
int ObPLCodeGenerateVisitor::visit(const ObPLLeaveStmt &s)
817
return generator_.generate_loop_control(s);
820
int ObPLCodeGenerateVisitor::visit(const ObPLIterateStmt &s)
822
return generator_.generate_loop_control(s);
825
int ObPLCodeGenerateVisitor::visit(const ObPLWhileStmt &s)
827
int ret = OB_SUCCESS;
828
if (NULL == generator_.get_current().get_v()) {830
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {831
LOG_WARN("failed to set insert point", K(ret));832
} else if (OB_FAIL(generator_.set_debug_location(s))) {833
LOG_WARN("failed to set debug location", K(ret));834
} else if (OB_FAIL(generator_.generate_goto_label(s))) {835
LOG_WARN("faile to generate goto lab", K(ret));837
ObLLVMBasicBlock while_begin;
838
ObLLVMBasicBlock continue_begin;
839
ObLLVMBasicBlock do_body;
840
ObLLVMBasicBlock alter_while;
841
ObLLVMValue count_value;
843
if (OB_FAIL(generator_.get_helper().create_block(ObString("while_begin"), generator_.get_func(), while_begin))) {844
LOG_WARN("failed to create block", K(s), K(ret));845
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("continue_begin"),846
generator_.get_func(), continue_begin))) {847
LOG_WARN("failed to create block", K(s), K(ret));848
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("do_body"), generator_.get_func(), do_body))) {849
LOG_WARN("failed to create block", K(s), K(ret));850
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("after_while"), generator_.get_func(), alter_while))) {851
LOG_WARN("failed to create block", K(s), K(ret));852
} else if (OB_FAIL(generator_.get_helper().create_ialloca(ObString("count_value"), ObIntType, 0, count_value))) {853
LOG_WARN("failed to create_ialloca", K(ret));854
} else if (s.has_label() && OB_FAIL(generator_.set_label(s.get_label(), s.get_level(), while_begin, alter_while))) {855
LOG_WARN("failed to set current", K(s), K(ret));856
} else if (OB_FAIL(generator_.get_helper().create_br(while_begin))) {857
LOG_WARN("failed to create_br", K(ret));858
} else if (OB_FAIL(generator_.set_current(while_begin))) {859
LOG_WARN("failed to set current", K(s), K(ret));861
ObLLVMValue p_result_obj;
863
ObLLVMValue is_false;
865
if (OB_ISNULL(s.get_body()) || OB_ISNULL(s.get_cond_expr())) {866
ret = OB_ERR_UNEXPECTED;
867
LOG_WARN("a if must have then body", K(s), K(s.get_body()), K(s.get_cond()), K(ret));868
} else if (OB_FAIL(generator_.get_helper().create_br(continue_begin))) {869
LOG_WARN("failed to create_br", K(ret));870
} else if (OB_FAIL(generator_.set_current(continue_begin))) {871
LOG_WARN("failed to set current", K(s), K(ret));872
} else if (OB_FAIL(generator_.get_helper().stack_save(stack))) {873
LOG_WARN("failed to stack_save", K(ret));874
} else if (OB_FAIL(generator_.generate_expr(s.get_cond(), s, OB_INVALID_INDEX,
876
LOG_WARN("failed to generate calc_expr func", K(ret));877
} else if (OB_FAIL(generator_.extract_value_from_objparam(p_result_obj, s.get_cond_expr()->get_data_type(), result))) {878
LOG_WARN("failed to extract_value_from_objparam", K(ret));879
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(result, FALSE, is_false))) {880
LOG_WARN("failed to create_icmp_eq", K(ret));881
} else if (OB_FAIL(generator_.get_helper().stack_restore(stack))) {882
LOG_WARN("failed to stack_restore", K(ret));883
} else if (OB_FAIL(generator_.get_helper().create_cond_br(is_false, alter_while, do_body))) {884
LOG_WARN("failed to create_cond_br", K(ret));885
} else if (OB_FAIL(generator_.set_current(do_body))) {886
LOG_WARN("failed to set current", K(s), K(ret));888
if (OB_FAIL(generator_.get_helper().stack_save(stack))) {889
LOG_WARN("failed to stack_save", K(ret));890
} else if (OB_FAIL(generator_.set_loop(stack, s.get_level(), continue_begin, alter_while))) {891
LOG_WARN("failed to set loop stack", K(ret));892
} else if (OB_FAIL(SMART_CALL(generate(*s.get_body())))) {893
LOG_WARN("failed to generate exception body", K(ret));894
} else if (OB_FAIL(generator_.reset_loop())) {895
LOG_WARN("failed to reset loop stack", K(ret));896
} else if (NULL != generator_.get_current().get_v()) {897
if (OB_FAIL(generator_.generate_early_exit(count_value, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {898
LOG_WARN("failed to generate calc_expr func", K(ret));899
} else if (OB_FAIL(generator_.generate_expr(s.get_cond(), s, OB_INVALID_INDEX,
901
LOG_WARN("failed to generate calc_expr func", K(ret));902
} else if (OB_FAIL(generator_.extract_value_from_objparam(p_result_obj, s.get_cond_expr()->get_data_type(), result))) {903
LOG_WARN("failed to extract_value_from_objparam", K(ret));904
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(result, FALSE, is_false))) {905
LOG_WARN("failed to create_icmp_eq", K(ret));906
} else if (OB_FAIL(generator_.get_helper().stack_restore(stack))) {907
LOG_WARN("failed to stack_restore", K(ret));908
} else if (OB_FAIL(generator_.get_helper().create_cond_br(is_false, alter_while, do_body))) {909
LOG_WARN("failed to create_cond_br", K(ret));910
} else { /*do nothing*/ }911
} else { /*do nothing*/ }914
if (OB_FAIL(generator_.set_current(alter_while))) {915
LOG_WARN("failed to set current", K(s), K(ret));916
} else if (s.has_label() && OB_FAIL(generator_.reset_label())) {917
LOG_WARN("failed to reset_label", K(s), K(ret));918
} else { /*do nothing*/ }926
int ObPLCodeGenerateVisitor::visit(const ObPLForLoopStmt &s)
928
int ret = OB_SUCCESS;
929
if (NULL == generator_.get_current().get_v()) {931
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {932
LOG_WARN("failed to set insert point", K(ret));933
} else if (OB_FAIL(generator_.set_debug_location(s))) {934
LOG_WARN("failed to set debug location", K(ret));935
} else if (OB_FAIL(generator_.generate_goto_label(s))) {936
LOG_WARN("failed to generate goto labe", K(ret));938
ObLLVMBasicBlock forloop_begin;
939
ObLLVMBasicBlock forloop_body;
940
ObLLVMBasicBlock forloop_continue;
941
ObLLVMBasicBlock forloop_end;
942
OZ (generator_.get_helper().create_block(ObString("forloop_begin"), generator_.get_func(), forloop_begin));943
OZ (generator_.get_helper().create_block(ObString("forloop_body"), generator_.get_func(), forloop_body));944
OZ (generator_.get_helper().create_block(ObString("forloop_continue"), generator_.get_func(), forloop_continue));945
OZ (generator_.get_helper().create_block(ObString("forloop_end"), generator_.get_func(), forloop_end));947
OZ (generator_.set_label(s.get_label(), s.get_level(), forloop_continue, forloop_end));
949
OZ (generator_.get_helper().create_br(forloop_begin));
950
OZ (generator_.set_current(forloop_begin));
952
ObLLVMValue count_value;
953
ObLLVMValue p_lower_obj, p_upper_obj, p_index_obj, p_index_value;
954
ObLLVMValue lower_obj, upper_obj, index_obj;
955
ObLLVMValue lower_value, upper_value, index_value;
956
ObLLVMValue is_true, stack;
957
ObLLVMValue allocator, into_obj, src_datum, dest_datum;
959
const ObPLVar *var = s.get_index_var();
961
CK (OB_NOT_NULL(var));
962
OZ (generator_.get_helper().create_ialloca(ObString("count_value"), ObIntType, 0, count_value));963
OZ (generator_.get_llvm_type(var->get_type(), ir_type));
964
OZ (generator_.get_helper().create_alloca(var->get_name(), ir_type, p_index_obj));
965
OZ (generator_.extract_allocator_from_context(generator_.get_vars().at(generator_.CTX_IDX), allocator));
966
OZ (generator_.extract_objparam_from_context(generator_.get_vars().at(generator_.CTX_IDX), s.get_ident(), into_obj));
967
OZ (generator_.extract_datum_ptr_from_objparam(into_obj, var->get_type().get_obj_type(), dest_datum));
968
OX (generator_.get_vars().at(s.get_ident() + generator_.USER_ARG_OFFSET) = p_index_obj);
971
OZ (generator_.generate_bound_and_check(s, s.get_is_forall(), lower_value, upper_value, lower_obj, upper_obj, forloop_end));
973
// 给INDEX附初始值，并存储进param_stroe
975
if (!s.get_reverse()) {977
OZ (generator_.get_helper().create_store(lower_obj, p_index_obj));
978
OZ (generator_.get_helper().create_store(lower_obj, dest_datum));
981
OZ (generator_.get_helper().create_store(upper_obj, p_index_obj));
982
OZ (generator_.get_helper().create_store(upper_obj, dest_datum));
985
if (s.is_values_bound()) {987
OZ (generator_.generate_expr(s.get_value(), s, s.get_ident(), p_value));
991
OZ (generator_.get_helper().create_br(forloop_body));
992
OZ (generator_.set_current(forloop_body));
996
OZ (generator_.get_helper().stack_save(stack));
997
OZ (generator_.set_loop(stack, s.get_level(), forloop_continue, forloop_end));
998
OZ (generator_.generate_early_exit(count_value, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
999
OZ (SMART_CALL(generate(*s.get_body())));
1000
OZ (generator_.reset_loop());
1002
&& NULL != generator_.get_current().get_v()
1003
&& generator_.get_current().get_v() != generator_.get_exit().get_v()) {1004
OZ (generator_.set_current(generator_.get_current()));
1005
OZ (generator_.get_helper().create_br(forloop_continue));
1009
OZ (generator_.set_current(forloop_continue));
1010
OZ (generator_.generate_next_and_check(s,
1021
OZ (generator_.get_helper().stack_restore(stack));
1022
OZ (generator_.get_helper().create_cond_br(is_true, forloop_body, forloop_end));
1027
OZ (generator_.set_current(forloop_end));
1028
if (s.has_label()) {1029
OZ (generator_.reset_label());
1037
int ObPLCodeGenerateVisitor::visit(const ObPLCursorForLoopStmt &s)
1039
int ret = OB_SUCCESS;
1040
if (NULL == generator_.get_current().get_v()) {1042
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1043
LOG_WARN("failed to set insert point", K(ret));1044
} else if (OB_FAIL(generator_.set_debug_location(s))) {1045
LOG_WARN("failed to set debug location", K(ret));1046
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1047
LOG_WARN("failed to generate goto labe", K(ret));1049
ObLLVMBasicBlock cursor_forloop_begin;
1050
ObLLVMBasicBlock cursor_forloop_body;
1051
ObLLVMBasicBlock cursor_forloop_end;
1052
ObLLVMBasicBlock cursor_forloop_fetch;
1053
ObLLVMBasicBlock cursor_forloop_check_success;
1054
ObLLVMValue ret_err;
1055
ObLLVMValue count_value;
1056
if (OB_FAIL(generator_.get_helper().create_block(ObString("cursor_forloop_begin"), generator_.get_func(), cursor_forloop_begin))) {1057
LOG_WARN("failed to create block", K(s), K(ret));1058
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("cursor_forloop_body"), generator_.get_func(), cursor_forloop_body))) {1059
LOG_WARN("failed to create block", K(s), K(ret));1060
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("cursor_forloop_end"), generator_.get_func(), cursor_forloop_end))) {1061
LOG_WARN("failed to create block", K(s), K(ret));1062
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("cursor_forloop_fetch"), generator_.get_func(), cursor_forloop_fetch))) {1063
LOG_WARN("failed to craete block", K(s), K(ret));1064
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("cursor_forloop_check_success"), generator_.get_func(), cursor_forloop_check_success))) {1065
LOG_WARN("failed to create block", K(s), K(ret));1066
} else if (s.has_label() && OB_FAIL(generator_.set_label(s.get_label(), s.get_level(), cursor_forloop_fetch, cursor_forloop_end))) {1067
LOG_WARN("failed to set current", K(s), K(ret));1068
} else if (OB_FAIL(generator_.get_helper().create_br(cursor_forloop_begin))) {1069
LOG_WARN("failed to create_br", K(ret));1072
const ObUserDefinedType *user_defined_type = s.get_user_type();
1073
const ObPLVar *var = s.get_index_var();
1074
if (OB_FAIL(generator_.set_current(cursor_forloop_begin))) {1075
LOG_WARN("failed to set current", K(s), K(ret));1076
} else if (OB_FAIL(generator_.get_helper().create_ialloca(ObString("count_value"), ObIntType, 0, count_value))) {1077
LOG_WARN("failed to create_ialloca", K(ret));1078
} else if (OB_ISNULL(user_defined_type)) {1079
ret = OB_ERR_UNEXPECTED;
1080
LOG_WARN("user defined type is null");1081
} else if (OB_FAIL(generator_.generate_user_type(*user_defined_type))) {1082
LOG_WARN("failed to generate user type", K(user_defined_type->get_type()));1083
} else if (OB_ISNULL(var)) {1084
ret = OB_ERR_UNEXPECTED;
1085
LOG_WARN("user var is null", K(s), K(ret));1087
if (var->get_type().is_composite_type()) {1088
ObSEArray<ObLLVMValue, 3> args;
1089
ObLLVMValue var_idx, init_value, var_value, extend_value;
1090
ObLLVMValue ret_err;
1091
ObLLVMValue var_type, type_id;
1092
ObLLVMValue null_int;
1093
int64_t init_size = 0;
1094
CK (OB_NOT_NULL(s.get_namespace()));
1095
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1096
OZ (generator_.get_helper().get_int8(var->get_type().get_type(), var_type));
1097
OZ (args.push_back(var_type));
1098
OZ (generator_.get_helper().get_int64(var->get_type().get_user_type_id(), type_id));
1099
OZ (args.push_back(type_id));
1100
OZ (generator_.get_helper().get_int64(s.get_index_index(), var_idx));
1101
OZ (args.push_back(var_idx));
1102
OZ (s.get_namespace()->get_size(PL_TYPE_INIT_SIZE, var->get_type(), init_size));
1103
OZ (generator_.get_helper().get_int32(init_size, init_value));
1104
OZ (args.push_back(init_value));
1105
OZ (generator_.generate_null_pointer(ObIntType, null_int));
1106
OZ (args.push_back(null_int));
1107
OZ (generator_.get_helper().create_call(ObString("spi_alloc_complex_var"),1108
generator_.get_spi_service().spi_alloc_complex_var_,
1111
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
1112
s.get_block()->in_notfound(),
1113
s.get_block()->in_warning()));
1114
OZ (generator_.extract_objparam_from_context(
1115
generator_.get_vars().at(generator_.CTX_IDX),
1116
s.get_index_index(),
1118
OZ (generator_.extract_extend_from_objparam(var_value, var->get_type(), extend_value));
1119
OZ (var->get_type().generate_construct(generator_, *s.get_namespace(),
1121
OZ (generator_.set_var_addr_to_param_store(s.get_index_index(), extend_value, init_value));
1122
generator_.get_vars().at(s.get_index_index() + generator_.USER_ARG_OFFSET) = extend_value;
1124
ret = OB_ERR_UNEXPECTED;
1125
LOG_WARN("cursor index is not a record", K(*var), K(ret));1128
if (OB_ISNULL(s.get_cursor())) {1129
ret = OB_ERR_UNEXPECTED;
1130
LOG_WARN("cursor is null", K(s.get_cursor_index()), K(s.get_cursor()), K(ret));1131
} else if (s.get_need_declare()
1132
&& generator_.generate_declare_cursor(static_cast<const ObPLStmt&>(s),
1133
s.get_cursor_index())) {1134
LOG_WARN("failed to generate declare cursor", K(ret));1135
} else if (OB_FAIL(generator_.generate_open(static_cast<const ObPLStmt&>(s),
1136
s.get_cursor()->get_value(),
1137
s.get_cursor()->get_package_id(),
1138
s.get_cursor()->get_routine_id(),
1140
LOG_WARN("failed to generate_open", K(s), K(ret));1141
} else if (OB_FAIL(generator_.get_helper().create_br(cursor_forloop_fetch))) {1142
LOG_WARN("failed to create_br cursor_forloop_fetch", K(ret));1148
ObLLVMValue is_not_found;
1150
CK (OB_NOT_NULL(s.get_cursor()));
1151
OZ (generator_.set_current(cursor_forloop_fetch));
1152
OZ (generator_.get_helper().stack_save(stack));
1153
OZ (generator_.set_loop(stack, s.get_level(), cursor_forloop_fetch, cursor_forloop_end, &s));
1154
OZ (generator_.generate_fetch(static_cast<const ObPLStmt&>(s),
1155
static_cast<const ObPLInto&>(s),
1156
s.get_cursor()->get_package_id(),
1157
s.get_cursor()->get_routine_id(),
1159
static_cast<int64_t>(INT64_MAX),
1162
OZ (generator_.get_helper().create_icmp_eq(ret_err, OB_READ_NOTHING, is_not_found));
1163
OZ (generator_.get_helper().stack_restore(stack));
1164
OZ (generator_.get_helper().create_cond_br(is_not_found, cursor_forloop_end, cursor_forloop_check_success));
1168
OZ (generator_.set_current(cursor_forloop_check_success));
1169
OZ (generator_.get_helper().stack_save(stack));
1170
OZ (generator_.check_success(ret_err,
1172
s.get_block()->in_notfound(),
1173
s.get_block()->in_warning()));
1174
OZ (generator_.get_helper().stack_restore(stack));
1175
OZ (generator_.get_helper().create_br(cursor_forloop_body));
1180
if (OB_FAIL(generator_.set_current(cursor_forloop_body))) {1181
LOG_WARN("failed to set current", K(s), K(ret));1182
} else if (OB_FAIL(generator_.get_helper().stack_save(stack))) {1183
LOG_WARN("failed to stack_save", K(ret));1184
} else if (OB_FAIL(SMART_CALL(generate(*s.get_body())))) {1185
LOG_WARN("failed to generate exception body", K(ret));1186
} else if (OB_FAIL(generator_.reset_loop())) {1187
LOG_WARN("failed to reset loop stack", K(ret));1188
} else { /*do nothing*/ }1191
&& NULL != generator_.get_current().get_v()
1192
&& generator_.get_current().get_v() != generator_.get_exit().get_v()) {1193
if (OB_FAIL(generator_.set_current(generator_.get_current()))) {1194
LOG_WARN("failed to set current", K(ret));1195
} else if (OB_FAIL(generator_.generate_early_exit(count_value, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {1196
LOG_WARN("failed to generate calc_expr func", K(ret));1197
} else if (OB_FAIL(generator_.get_helper().stack_restore(stack))) {1198
LOG_WARN("failed to stack_restore", K(ret));1199
} else if (OB_FAIL(generator_.get_helper().create_br(cursor_forloop_fetch))) {1200
LOG_WARN("failed to create_br", K(ret));1206
OZ (generator_.set_current(cursor_forloop_end));
1207
CK (OB_NOT_NULL(s.get_cursor()));
1208
OZ (generator_.generate_close(static_cast<const ObPLStmt&>(s),
1209
s.get_cursor()->get_package_id(),
1210
s.get_cursor()->get_routine_id(),
1212
if (s.has_label()) {1213
OZ (generator_.reset_label());
1220
int ObPLCodeGenerateVisitor::visit(const ObPLForAllStmt &s)
1222
int ret = OB_SUCCESS;
1223
if (NULL == generator_.get_current().get_v()) {1226
OZ (generator_.get_helper().set_insert_point(generator_.get_current()));
1227
OZ (generator_.set_debug_location(s));
1228
OZ (generator_.generate_goto_label(s));
1231
if (OB_SUCC(ret) && OB_NOT_NULL(generator_.get_current().get_v())) {1232
ObSEArray<ObLLVMValue, 2> args;
1233
ObLLVMValue ret_err;
1234
ObLLVMValue is_save_exception;
1235
OZ (generator_.get_helper().get_int8(static_cast<int64_t>(s.get_save_exception()), is_save_exception));
1236
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1237
OZ (args.push_back(is_save_exception));
1238
OZ (generator_.get_helper().create_call(ObString("set_implicit_cursor_in_forall"),1239
generator_.get_set_implicit_cursor_in_forall_func(),
1242
OZ (generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
1244
// 执行forall，forall的循环体中只会有一句DML，不会出现跳转，因此这里不判断控制流是否断开
1245
if (OB_SUCC(ret) && OB_NOT_NULL(generator_.get_current().get_v())) {1246
const ObPLForLoopStmt& for_loop = static_cast<const ObPLForLoopStmt&>(s);
1247
if (OB_NOT_NULL(s.get_sql_stmt()) && !s.get_save_exception()) {1248
ObLLVMValue lower, upper, lower_obj, upper_obj, p_index_obj;
1249
ObLLVMValue ret_err, is_need_rollback;
1251
ObLLVMBasicBlock illegal_block, after_block, rollback_block, not_rollback_block;
1252
ObPLSqlStmt *sql_stmt = const_cast<ObPLSqlStmt*>(s.get_sql_stmt());
1253
const ObPLVar *var = s.get_index_var();
1254
sql_stmt->set_forall_sql(true);
1255
CK (OB_NOT_NULL(var));
1256
OZ (generator_.get_helper().create_block(ObString("illegal_block"), generator_.get_func(), illegal_block));1257
OZ (generator_.get_helper().create_block(ObString("after_block"), generator_.get_func(), after_block));1258
OZ (generator_.get_helper().create_block(ObString("rollback_block"), generator_.get_func(), rollback_block));1259
OZ (generator_.get_helper().create_block(ObString("not_rollback_block"), generator_.get_func(), not_rollback_block));1260
OZ (generator_.get_llvm_type(var->get_type(), ir_type));
1261
OZ (generator_.get_helper().create_alloca(var->get_name(), ir_type, p_index_obj));
1262
OX (generator_.get_vars().at(s.get_ident() + generator_.USER_ARG_OFFSET) = p_index_obj);
1263
OZ (generator_.generate_bound_and_check(s, true, lower, upper, lower_obj, upper_obj, illegal_block));
1264
OZ (generator_.generate_sql(*(s.get_sql_stmt()), ret_err));
1265
OZ (generator_.get_helper().create_icmp_eq(ret_err, OB_BATCHED_MULTI_STMT_ROLLBACK, is_need_rollback));
1266
OZ (generator_.get_helper().create_cond_br(is_need_rollback, rollback_block, not_rollback_block));
1267
OZ (generator_.set_current(not_rollback_block));
1268
OZ (generator_.generate_after_sql(*(s.get_sql_stmt()), ret_err));
1269
OZ (generator_.get_helper().create_br(after_block));
1270
OZ (generator_.set_current(rollback_block));
1271
sql_stmt->set_forall_sql(false);
1272
OZ (visit(for_loop));
1273
OZ (generator_.get_helper().create_br(after_block));
1274
OZ (generator_.get_helper().set_insert_point(illegal_block));
1275
OZ (generator_.get_helper().create_br(after_block));
1276
OZ (generator_.set_current(after_block));
1278
OZ (visit(for_loop));
1281
// 设置隐式游标不在forall环境中
1282
if (OB_SUCC(ret) && OB_NOT_NULL(generator_.get_current().get_v())) {1283
ObSEArray<ObLLVMValue, 2> args;
1284
ObLLVMValue ret_err;
1285
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1286
OZ (generator_.get_helper().create_call(ObString("unset_implicit_cursor_in_forall"),1287
generator_.get_unset_implicit_cursor_in_forall_func(),
1290
OZ (generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
1295
int ObPLCodeGenerateVisitor::visit(const ObPLRepeatStmt &s)
1297
int ret = OB_SUCCESS;
1298
if (NULL == generator_.get_current().get_v()) {1300
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1301
LOG_WARN("failed to set insert point", K(ret));1302
} else if (OB_FAIL(generator_.set_debug_location(s))) {1303
LOG_WARN("failed to set debug location", K(ret));1304
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1305
LOG_WARN("failed to generate goto label", K(ret));1307
ObLLVMBasicBlock repeat;
1308
ObLLVMBasicBlock alter_repeat;
1309
ObLLVMValue count_value;
1311
if (OB_FAIL(generator_.get_helper().create_block(ObString("repeat"), generator_.get_func(), repeat))) {1312
LOG_WARN("failed to create block", K(s), K(ret));1313
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("after_repeat"), generator_.get_func(), alter_repeat))) {1314
LOG_WARN("failed to create block", K(s), K(ret));1315
} else if (s.has_label() && OB_FAIL(generator_.set_label(s.get_label(), s.get_level(), repeat, alter_repeat))) {1316
LOG_WARN("failed to set current", K(s), K(ret));1317
} else if (OB_FAIL(generator_.get_helper().create_ialloca(ObString("count_value"), ObIntType, 0, count_value))) {1318
LOG_WARN("failed to create_ialloca", K(ret));1319
} else if (OB_FAIL(generator_.get_helper().create_br(repeat))) {1320
LOG_WARN("failed to create_br", K(ret));1321
} else if (OB_FAIL(generator_.set_current(repeat))) {1322
LOG_WARN("failed to set current", K(s), K(ret));1325
ObLLVMValue p_result_obj;
1327
ObLLVMValue is_false;
1328
if (OB_FAIL(generator_.get_helper().stack_save(stack))) {1329
LOG_WARN("failed to stack_save", K(ret));1330
} else if (OB_ISNULL(s.get_body()) || OB_ISNULL(s.get_cond_expr())) {1331
ret = OB_ERR_UNEXPECTED;
1332
LOG_WARN("a if must have then body", K(s), K(s.get_body()), K(s.get_cond()), K(ret));1333
} else if (OB_FAIL(generator_.set_loop(stack, s.get_level(), repeat, alter_repeat))) {1334
LOG_WARN("failed to set loop stack", K(ret));1335
} else if (OB_FAIL(SMART_CALL(generate(*s.get_body())))) {1336
LOG_WARN("failed to generate exception body", K(ret));1337
} else if (OB_FAIL(generator_.reset_loop())) {1338
LOG_WARN("failed to reset loop stack", K(ret));1339
} else if (NULL != generator_.get_current().get_v()) {1340
if (OB_FAIL(generator_.generate_early_exit(count_value, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {1341
LOG_WARN("failed to generate calc_expr func", K(ret));1342
} else if (OB_FAIL(generator_.generate_expr(s.get_cond(), s, OB_INVALID_INDEX,
1344
LOG_WARN("failed to generate calc_expr func", K(ret));1345
} else if (OB_FAIL(generator_.extract_value_from_objparam(p_result_obj, s.get_cond_expr()->get_data_type(), result))) {1346
LOG_WARN("failed to extract_value_from_objparam", K(ret));1347
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(result, FALSE, is_false))) {1348
LOG_WARN("failed to create_icmp_eq", K(ret));1349
} else if (OB_FAIL(generator_.get_helper().stack_restore(stack))) {1350
LOG_WARN("failed to stack_restore", K(ret));1351
} else if (OB_FAIL(generator_.get_helper().create_cond_br(is_false, repeat, alter_repeat))) {1352
LOG_WARN("failed to create_cond_br", K(ret));1354
} else { /*do nothing*/ }1357
if (OB_FAIL(generator_.set_current(alter_repeat))) {1358
LOG_WARN("failed to set current", K(s), K(ret));1359
} else if (s.has_label() && OB_FAIL(generator_.reset_label())) {1360
LOG_WARN("failed to reset_label", K(s), K(ret));1361
} else { /*do nothing*/ }1368
int ObPLCodeGenerateVisitor::visit(const ObPLLoopStmt &s)
1370
int ret = OB_SUCCESS;
1371
if (NULL == generator_.get_current().get_v()) {1373
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1374
LOG_WARN("failed to set insert point", K(ret));1375
} else if (OB_FAIL(generator_.set_debug_location(s))) {1376
LOG_WARN("failed to set debug location", K(ret));1377
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1378
LOG_WARN("failed to generate goto label", K(ret));1380
ObLLVMBasicBlock loop;
1381
ObLLVMBasicBlock alter_loop;
1382
ObLLVMValue count_value;
1384
if (OB_FAIL(generator_.get_helper().create_block(ObString("loop"), generator_.get_func(), loop))) {1385
LOG_WARN("failed to create block", K(s), K(ret));1386
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("after_loop"), generator_.get_func(), alter_loop))) {1387
LOG_WARN("failed to create block", K(s), K(ret));1388
} else if (s.has_label() && OB_FAIL(generator_.set_label(s.get_label(), s.get_level(), loop, alter_loop))) {1389
LOG_WARN("failed to set current", K(s), K(ret));1390
} else if (OB_FAIL(generator_.get_helper().create_ialloca(ObString("count_value"), ObIntType, 0, count_value))) {1391
LOG_WARN("failed to create_ialloca", K(ret));1392
} else if (OB_FAIL(generator_.get_helper().create_br(loop))) {1393
LOG_WARN("failed to create_br", K(ret));1394
} else if (OB_FAIL(generator_.set_current(loop))) {1395
LOG_WARN("failed to set current", K(s), K(ret));1398
if (OB_FAIL(generator_.get_helper().stack_save(stack))) {1399
LOG_WARN("failed to stack_save", K(ret));1400
} else if (OB_FAIL(generator_.set_loop(stack, s.get_level(), loop, alter_loop))) {1401
LOG_WARN("failed to set loop stack", K(ret));1402
} else if (OB_ISNULL(s.get_body())) {1403
ret = OB_ERR_UNEXPECTED;
1404
LOG_WARN("a if must have valid body", K(s), K(s.get_body()), K(ret));1405
} else if (OB_FAIL(SMART_CALL(generate(*s.get_body())))) {1406
LOG_WARN("failed to generate exception body", K(ret));1407
} else if (OB_FAIL(generator_.reset_loop())) {1408
LOG_WARN("failed to reset loop stack", K(ret));1409
} else if (NULL != generator_.get_current().get_v()) {1410
if (OB_FAIL(generator_.generate_early_exit(count_value, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {1411
LOG_WARN("failed to generate calc_expr func", K(ret));1412
} else if (OB_FAIL(generator_.get_helper().stack_restore(stack))) {1413
LOG_WARN("failed to stack_restore", K(ret));1414
} else if (OB_FAIL(generator_.get_helper().create_br(loop))) {1415
LOG_WARN("failed to create_cond_br", K(ret));1416
} else { /*do nothing*/ }1417
} else { /*do nothing*/ }1420
if (OB_FAIL(generator_.set_current(alter_loop))) {1421
LOG_WARN("failed to set current", K(s), K(ret));1422
} else if (s.has_label() && OB_FAIL(generator_.reset_label())) {1423
LOG_WARN("failed to reset_label", K(s), K(ret));1424
} else { /*do nothing*/ }1431
int ObPLCodeGenerateVisitor::visit(const ObPLReturnStmt &s)
1433
int ret = OB_SUCCESS;
1434
if (NULL == generator_.get_current().get_v()) {1436
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1437
LOG_WARN("failed to set insert point", K(ret));1438
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1439
LOG_WARN("failed to generate goto label", K(ret));1441
ObLLVMBasicBlock normal_return;
1442
if (OB_FAIL(generator_.get_helper().create_block(ObString("return"), generator_.get_func(), normal_return))) {1443
LOG_WARN("failed to create block", K(s), K(ret));1444
} else if (OB_FAIL(generator_.get_helper().create_br(normal_return))) {1445
LOG_WARN("failed to create_br", K(ret));1446
} else if (OB_FAIL(generator_.set_current(normal_return))) {1447
LOG_WARN("failed to set current", K(s), K(ret));1448
} else if (OB_FAIL(generator_.set_debug_location(s))) {1449
LOG_WARN("failed to set debug location", K(ret));1450
} else if (s.get_ret() != OB_INVALID_INDEX) {1451
ObLLVMValue p_result_obj;
1453
ObLLVMValue p_result;
1454
OZ (generator_.generate_expr(s.get_ret(), s, OB_INVALID_INDEX, p_result_obj));
1455
if (OB_SUCC(ret) && lib::is_oracle_mode()) { // check logic need before store function ret value1456
if (generator_.get_ast().is_autonomous() &&
1457
OB_FAIL(generator_.generate_check_autonomos(s))) {1458
LOG_WARN("failed to generate_check_autonomos", K(ret));1461
if (OB_SUCC(ret) && generator_.get_ast().get_ret_type().is_composite_type()) {1462
//return NULL as UDT means returning a uninitialized UDT object
1463
ObLLVMBasicBlock null_branch;
1464
ObLLVMBasicBlock final_branch;
1465
ObLLVMValue p_type_value;
1466
ObLLVMValue type_value;
1467
ObLLVMValue is_null;
1468
ObLLVMValue p_obj_value;
1469
ObLLVMValue obj_value;
1470
const ObUserDefinedType *user_type = NULL;
1471
OZ (generator_.get_helper().create_block(ObString("null_branch"),1472
generator_.get_func(),
1474
OZ (generator_.get_helper().create_block(ObString("final_branch"),1475
generator_.get_func(),
1477
OZ (generator_.extract_type_ptr_from_objparam(p_result_obj, p_type_value));
1478
OZ (generator_.get_helper().create_load(ObString("load_type"), p_type_value, type_value));1479
OZ (generator_.get_helper().create_icmp_eq(type_value, ObNullType, is_null));
1480
OZ (generator_.get_helper().create_cond_br(is_null, null_branch, final_branch));
1483
OZ (generator_.set_current(null_branch));
1484
OZ (s.get_namespace()->get_user_type(generator_.get_ast().get_ret_type().get_user_type_id(),
1487
ObSEArray<ObLLVMValue, 3> args;
1488
ObLLVMType int_type;
1489
jit::ObLLVMType ir_type, ir_ptr_type;
1490
ObLLVMValue var_idx, init_value, extend_ptr, extend_value, composite_ptr, p_obj;
1491
ObLLVMValue ret_err;
1492
ObLLVMValue var_type, type_id;
1493
int64_t init_size = 0;
1495
CK (OB_NOT_NULL(s.get_namespace()));
1496
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1497
OZ (generator_.get_helper().get_int8(user_type->get_type(), var_type));
1498
OZ (args.push_back(var_type));
1499
OZ (generator_.get_helper().get_int64(
1500
generator_.get_ast().get_ret_type().get_user_type_id(),
1502
OZ (args.push_back(type_id));
1503
OZ (generator_.get_helper().get_int64(OB_INVALID_INDEX, var_idx));
1504
OZ (args.push_back(var_idx));
1505
OZ (user_type->get_size(*s.get_namespace(), PL_TYPE_INIT_SIZE, init_size));
1506
OZ (generator_.get_helper().get_int32(init_size, init_value));
1507
OZ (args.push_back(init_value));
1508
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
1509
OZ (generator_.get_helper().create_alloca(ObString("exception_type"), int_type, extend_ptr));1510
OZ (args.push_back(extend_ptr));
1511
OZ (generator_.get_helper().create_call(ObString("spi_alloc_complex_var"),1512
generator_.get_spi_service().spi_alloc_complex_var_,
1515
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
1516
s.get_block()->in_notfound(),
1517
s.get_block()->in_warning()));
1518
// Step 2: 初始化类型内容, 如Collection的rowsize,element type等
1519
OZ (generator_.get_helper().create_load("load_extend", extend_ptr, extend_value));1520
OZ (generator_.get_llvm_type(*user_type, ir_type));
1521
OZ (ir_type.get_pointer_to(ir_ptr_type));
1522
OZ (generator_.get_helper().create_int_to_ptr(ObString("cast_extend_to_ptr"), extend_value, ir_ptr_type, composite_ptr));1523
OZ (user_type->ObPLDataType::generate_construct( //must call ObPLDataType's
1524
generator_, *s.get_namespace(), composite_ptr, &s));
1525
OZ (generator_.get_helper().create_gep(ObString("extract_obj_pointer"), p_result_obj, 0, p_obj));1526
OZ (generator_.generate_set_extend(p_obj, var_type, init_value, extend_value));
1527
OZ (generator_.finish_current(final_branch));
1528
OZ (generator_.set_current(final_branch));
1530
OZ (generator_.extract_obobj_from_objparam(p_result_obj, result));
1531
OZ (generator_.extract_result_from_context(
1532
generator_.get_vars().at(generator_.CTX_IDX), p_result));
1533
CK (OB_NOT_NULL(s.get_ret_expr()));
1535
} else if (s.get_ret_expr()->is_obj_access_expr()) {1536
const ObObjAccessRawExpr *obj_access
1537
= static_cast<const ObObjAccessRawExpr*>(s.get_ret_expr());
1538
const common::ObIArray<pl::ObObjAccessIdx> *access_idxs = NULL;
1539
ObPLDataType pl_type;
1540
int64_t local_idx = OB_INVALID_INDEX;
1541
CK (OB_NOT_NULL(obj_access));
1542
CK (OB_NOT_NULL(access_idxs = &(obj_access->get_access_idxs())));
1543
OZ (obj_access->get_final_type(pl_type));
1544
OX (local_idx = ObObjAccessIdx::get_local_variable_idx(*access_idxs));
1546
} else if (ObObjAccessIdx::is_local_variable(*access_idxs)
1547
&& local_idx < access_idxs->count()
1548
&& access_idxs->at(local_idx).elem_type_.is_collection_type()
1549
&& pl_type.is_obj_type()) {1550
ObLLVMValue allocator;
1551
ObLLVMValue src_datum;
1552
ObLLVMValue dest_datum;
1553
OZ (generator_.extract_allocator_from_context(
1554
generator_.get_vars().at(generator_.CTX_IDX), allocator));
1555
OZ (generator_.extract_datum_ptr_from_objparam(
1556
p_result_obj, pl_type.get_obj_type(), src_datum));
1557
OZ (generator_.extract_datum_ptr_from_objparam(
1558
p_result, pl_type.get_obj_type(), dest_datum));
1559
OZ (pl_type.generate_copy(generator_,
1560
*(s.get_namespace()),
1564
s.get_block()->in_notfound(),
1565
s.get_block()->in_warning(),
1568
OZ (generator_.get_helper().create_store(result, p_result));
1571
OZ (generator_.get_helper().create_store(result, p_result));
1573
if (OB_SUCC(ret) && s.is_return_ref_cursor_type()) {1574
ObSEArray<ObLLVMValue, 16> args;
1577
OZ (args.push_back(generator_.get_vars()[generator_.CTX_IDX]));
1578
OZ (args.push_back(p_result));
1579
OZ (generator_.get_helper().get_int64(1, addend));
1580
OZ (args.push_back(addend));
1581
jit::ObLLVMValue ret_err;
1582
// 这儿为啥需要对ref count +1, 因为一个被return的ref cursor，在函数block结束的时候，会被dec ref
1583
// 那么这个时候可能会减到0， 从而导致这个被return的ref cursor被close了。
1584
// 这个+1，在ob_expr_udf那儿会对这个ref cursor -1进行平衡操作。
1585
OZ (generator_.get_helper().create_call(ObString("spi_add_ref_cursor_refcount"),1586
generator_.get_spi_service().spi_add_ref_cursor_refcount_,
1589
OZ (generator_.check_success(ret_err,
1591
s.get_block()->in_notfound(),
1592
s.get_block()->in_warning()));
1596
LOG_DEBUG("generate return stmt, close cursor",1597
K(generator_.get_ast().get_cursor_table().get_count()),
1599
K(generator_.get_ast().get_name()));
1600
OZ (generator_.generate_close_loop_cursor(false, 0));
1603
for (int64_t i = 0; OB_SUCC(ret) && i < generator_.get_ast().get_cursor_table().get_count(); ++i) {1604
const ObPLCursor *cursor = generator_.get_ast().get_cursor_table().get_cursor(i);
1605
OZ (generator_.generate_handle_ref_cursor(cursor, s, false, false));
1607
ObLLVMValue ret_value;
1608
ObLLVMBasicBlock null_block;
1610
} else if (OB_FAIL(generator_.get_helper().create_load(ObString("load_ret"), generator_.get_vars().at(generator_.RET_IDX), ret_value))) {1611
LOG_WARN("failed to create_load", K(ret));1612
} else if (OB_FAIL(generator_.get_helper().create_ret(ret_value))) {1613
LOG_WARN("failed to create_ret", K(ret));1614
} else if (OB_FAIL(generator_.set_current(null_block))) { // Return语句会结束函数, 切断控制流, 后面的语句不再Codegen1615
LOG_WARN("failed to set current", K(s), K(ret));1622
int ObPLCodeGenerateVisitor::visit(const ObPLSqlStmt &s)
1624
int ret = OB_SUCCESS;
1625
if (NULL == generator_.get_current().get_v()) {1627
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1628
LOG_WARN("failed to generate goto label", K(ret));1630
ObLLVMValue ret_err;
1632
OZ (generator_.get_helper().stack_save(stack));
1633
OZ (generator_.generate_sql(s, ret_err));
1634
OZ (generator_.generate_after_sql(s, ret_err));
1635
OZ (generator_.get_helper().stack_restore(stack));
1640
int ObPLCodeGenerateVisitor::visit(const ObPLExecuteStmt &s)
1642
int ret = OB_SUCCESS;
1643
if (NULL == generator_.get_current().get_v()) {1646
ObLLVMType int_type;
1647
ObLLVMValue null_pointer;
1648
ObLLVMValue int_value;
1649
ObSEArray<ObLLVMValue, 16> args;
1650
ObLLVMValue sql_addr;
1652
ObLLVMType params_type;
1654
ObLLVMValue into_array_value;
1655
ObLLVMValue into_count_value;
1656
ObLLVMValue type_array_value;
1657
ObLLVMValue type_count_value;
1658
ObLLVMValue exprs_not_null_array_value;
1659
ObLLVMValue pl_integer_range_array_value;
1660
ObLLVMValue is_bulk;
1661
ObLLVMValue is_returning, is_type_record;
1662
ObLLVMValue ret_err;
1664
OZ (generator_.get_helper().set_insert_point(generator_.get_current()));
1665
OZ (generator_.set_debug_location(s));
1666
OZ (generator_.generate_goto_label(s));
1668
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
1669
OZ (generator_.generate_null_pointer(ObIntType, null_pointer));
1671
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX))); //PL的执行环境
1673
* 为什么sql和using同样都是表达式，sql直接传rawexpr，而using调用generate_expr传入obobjparam？？？
1674
* 这是因为直接传rawexpr，由spi_execute_immediate进行计算会省掉一次spi交互。
1675
* 而using不仅是传入参数，还可以做传出参数，所以必须用obobjparam向外传递结果。
1677
OZ (generator_.generate_pointer(generator_.get_expr(s.get_sql()), sql_addr));
1678
OZ (args.push_back(sql_addr));
1680
// param exprs & param count
1681
ObLLVMType param_mode_arr_type; //param mode array elem type
1682
ObLLVMValue param_mode_arr_value; // param mode array
1683
ObLLVMType param_mode_arr_pointer;
1685
} else if (s.get_using().empty()) {1686
OZ (generator_.get_helper().create_ptr_to_int(
1687
ObString("cast_pointer_to_int"), null_pointer, int_type, int_value));1688
OZ (args.push_back(int_value));
1690
OZ (args.push_back(null_pointer));
1692
OZ (generator_.get_adt_service().get_argv(s.get_using().count(), params_type));
1693
OZ (generator_.get_helper().create_alloca(
1694
ObString("execute_immediate_params"), params_type, params));1696
OZ (int_type.get_pointer_to(param_mode_arr_pointer));
1697
OZ (ObLLVMHelper::get_array_type(int_type,
1698
s.get_using().count(),
1699
param_mode_arr_type));
1700
OZ (generator_.get_helper().create_alloca(ObString("param_mode_array"),1701
param_mode_arr_type,
1702
param_mode_arr_value));
1703
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_using().count(); ++i) {1704
ObLLVMValue p_result_obj;
1707
ObLLVMValue param_mode_value;
1708
ObLLVMValue param_mode_arr_elem;
1709
OZ (generator_.get_helper().get_int64(s.get_using().at(i).mode_, param_mode_value));
1710
OZ (generator_.get_helper().create_gep(ObString("extract_param_mode"),1711
param_mode_arr_value, i, param_mode_arr_elem));
1712
OZ (generator_.get_helper().create_store(param_mode_value, param_mode_arr_elem));
1714
#define GET_USING_EXPR(idx) (generator_.get_ast().get_expr(s.get_using_index(idx)))
1716
int64_t udt_id = GET_USING_EXPR(i)->get_result_type().get_udt_id();
1717
if (s.is_pure_out(i)) {1718
OZ (generator_.generate_new_objparam(p_result_obj, udt_id));
1719
} else if (!GET_USING_EXPR(i)->is_obj_access_expr()
1720
|| !(static_cast<const ObObjAccessRawExpr *>(GET_USING_EXPR(i))->for_write())) {1721
OZ (generator_.generate_expr(s.get_using_index(i), s, OB_INVALID_INDEX, p_result_obj));
1723
ObLLVMValue address;
1724
ObPLDataType final_type;
1725
const ObObjAccessRawExpr *obj_access
1726
= static_cast<const ObObjAccessRawExpr *>(GET_USING_EXPR(i));
1727
CK (OB_NOT_NULL(obj_access));
1728
OZ (obj_access->get_final_type(final_type));
1729
OZ (generator_.generate_expr(s.get_using_index(i),
1734
} else if (final_type.is_obj_type()) {1735
ObLLVMType obj_type;
1736
ObLLVMType obj_type_ptr;
1738
ObLLVMValue src_obj;
1739
ObLLVMValue p_dest_obj;
1740
OZ (generator_.generate_new_objparam(p_result_obj));
1741
OZ (generator_.extract_extend_from_objparam(address, final_type, p_obj));
1742
OZ (generator_.get_adt_service().get_obj(obj_type));
1743
OZ (obj_type.get_pointer_to(obj_type_ptr));
1744
OZ (generator_.get_helper().create_bit_cast(
1745
ObString("cast_addr_to_obj_ptr"), p_obj, obj_type_ptr, p_obj));1746
OZ (generator_.get_helper().create_load(ObString("load obj value"), p_obj, src_obj));1747
OZ (generator_.extract_datum_ptr_from_objparam(p_result_obj, ObNullType, p_dest_obj));
1748
OZ (generator_.get_helper().create_store(src_obj, p_dest_obj));
1750
ObLLVMValue allocator;
1751
ObLLVMValue src_datum;
1752
ObLLVMValue dest_datum;
1753
int64_t udt_id = GET_USING_EXPR(i)->get_result_type().get_udt_id();
1754
OZ (generator_.extract_allocator_from_context(
1755
generator_.get_vars().at(generator_.CTX_IDX), allocator));
1756
OZ (generator_.generate_new_objparam(p_result_obj, udt_id));
1757
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, dest_datum));
1758
OZ (generator_.extract_obobj_ptr_from_objparam(address, src_datum));
1759
OZ (final_type.generate_copy(generator_,
1764
s.get_block()->in_notfound(),
1765
s.get_block()->in_warning(),
1770
#undef GET_USING_EXPR
1772
OZ (generator_.get_helper().create_ptr_to_int(
1773
ObString("cast_arg_to_pointer"), p_result_obj, int_type, p_arg));1774
OZ (generator_.extract_arg_from_argv(params, i, pp_arg));
1775
OZ (generator_.get_helper().create_store(p_arg, pp_arg));
1777
OZ (generator_.get_helper().create_ptr_to_int(
1778
ObString("cast_pointer_to_int"), params, int_type, int_value));1779
OZ (args.push_back(int_value));
1781
OZ (generator_.get_helper().create_bit_cast(ObString("cast_param_mode_arr_pointer"),1782
param_mode_arr_value, param_mode_arr_pointer, param_mode_arr_value));
1783
OZ (args.push_back(param_mode_arr_value));
1786
OZ (generator_.get_helper().get_int64(s.get_using().count(), int_value));
1787
OZ (args.push_back(int_value));
1790
//result_exprs & result_count
1791
OZ (generator_.generate_into(s, into_array_value, into_count_value,
1792
type_array_value, type_count_value,
1793
exprs_not_null_array_value,
1794
pl_integer_range_array_value,
1796
OZ (args.push_back(into_array_value));
1797
OZ (args.push_back(into_count_value));
1798
OZ (args.push_back(type_array_value));
1799
OZ (args.push_back(type_count_value));
1800
OZ (args.push_back(exprs_not_null_array_value));
1801
OZ (args.push_back(pl_integer_range_array_value));
1802
OZ (args.push_back(is_bulk));
1803
OZ (generator_.get_helper().get_int8(s.get_is_returning(), is_returning));
1804
OZ (args.push_back(is_returning));
1805
OZ (generator_.get_helper().get_int8(s.is_type_record(), is_type_record));
1806
OZ (args.push_back(is_type_record));
1809
OZ (generator_.get_helper().create_call(
1810
ObString("spi_execute_immediate"),1811
generator_.get_spi_service().spi_execute_immediate_, args, ret_err));
1812
OZ (generator_.check_success(
1813
ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
1816
OZ (generator_.generate_into_restore(s.get_into(), s.get_exprs(), s.get_symbol_table()));
1819
OZ (generator_.generate_out_params(s, s.get_using(), params));
1824
#define COLLECTION_STMT_COMM(expr) \
1825
const ObObjAccessRawExpr *access_expr = NULL; \
1826
ObPLDataType type; \
1827
const ObUserDefinedType *user_type = NULL; \
1828
const ObPLBlockNS *ns = NULL; \
1829
uint64_t type_id = OB_INVALID_ID; \
1830
int64_t row_size = 0; \
1831
int64_t filed_cnt = 0; \
1832
uint64_t package_id = OB_INVALID_ID; \
1833
uint64_t var_idx = OB_INVALID_ID; \
1834
OZ (generator_.get_helper().set_insert_point(generator_.get_current())); \
1835
CK (OB_NOT_NULL(expr)); \
1836
CK (expr->is_obj_access_expr()); \
1837
CK (OB_NOT_NULL(access_expr = static_cast<const ObObjAccessRawExpr*>(expr))); \
1838
OZ (access_expr->get_final_type(type)); \
1839
CK (OB_INVALID_ID != (type_id = type.get_user_type_id())); \
1840
CK (OB_NOT_NULL(ns = s.get_namespace())); \
1841
CK (OB_NOT_NULL(s.get_namespace()->get_type_table())); \
1843
&& OB_ISNULL(user_type = s.get_namespace()->get_type_table()->get_type(type_id))) { \1844
CK (OB_NOT_NULL(user_type \
1845
= s.get_namespace()->get_type_table()->get_external_type(type_id))); \
1847
OZ (user_type->get_size(*s.get_namespace(), PL_TYPE_ROW_SIZE, row_size)); \
1848
OZ (user_type->get_field_count(*s.get_namespace(), filed_cnt)); \
1850
&& ObObjAccessIdx::is_package_variable(access_expr->get_access_idxs())) { \1851
OZ (ObObjAccessIdx::get_package_id(access_expr, package_id, &var_idx)); \
1854
int ObPLCodeGenerateVisitor::visit(const ObPLExtendStmt &s)
1856
int ret = OB_SUCCESS;
1857
if (NULL == generator_.get_current().get_v()) {1859
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1860
LOG_WARN("failed to set insert point", K(ret));1861
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1862
LOG_WARN("failed to generate goto label", K(ret));1864
COLLECTION_STMT_COMM(s.get_extend_expr());
1867
ObLLVMValue int_value;
1868
ObSEArray<ObLLVMValue, 16> args;
1869
if (OB_FAIL(args.push_back(generator_.get_vars().at(generator_.CTX_IDX)))) { //PL的执行环境1870
LOG_WARN("push_back error", K(ret));1871
} else if (OB_FAIL(generator_.generate_pointer(generator_.get_expr(s.get_extend()), int_value))) {1872
LOG_WARN("failed to generate a pointer", K(ret));1873
} else if (OB_FAIL(args.push_back(int_value))) {1874
LOG_WARN("push_back error", K(ret));1875
} else if (OB_FAIL(generator_.get_helper().get_int64(filed_cnt, int_value))) {1876
LOG_WARN("failed to get int64", K(ret));1877
} else if (OB_FAIL(args.push_back(int_value))) {1878
LOG_WARN("push_back error", K(ret));1879
} else if (OB_FAIL(generator_.generate_pointer(generator_.get_expr(s.get_n()), int_value))) {1880
LOG_WARN("failed to get int64", K(ret));1881
} else if (OB_FAIL(args.push_back(int_value))) {1882
LOG_WARN("push_back error", K(ret));1883
} else if (OB_FAIL(generator_.generate_pointer(generator_.get_expr(s.get_i()), int_value))) {1884
LOG_WARN("failed to get int64", K(ret));1885
} else if (OB_FAIL(args.push_back(int_value))) {1886
LOG_WARN("push_back error", K(ret));1887
} else if (OB_FAIL(generator_.get_helper().get_int64(package_id, int_value))) {1888
LOG_WARN("failed to get int64", K(ret));1889
} else if (OB_FAIL(args.push_back(int_value))) {1890
LOG_WARN("push_back error", K(ret));1891
} else { /*do nothing*/ }1894
ObLLVMValue ret_err;
1895
if (OB_FAIL(generator_.get_helper().create_call(ObString("spi_extend_collection"), generator_.get_spi_service().spi_extend_collection_, args, ret_err))) {1896
LOG_WARN("failed to create call", K(ret));1897
} else if (OB_FAIL(generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {1898
LOG_WARN("failed to check success", K(ret));1899
} else { /*do nothing*/ }1901
if (OB_SUCC(ret) && package_id != OB_INVALID_ID && var_idx != OB_INVALID_ID) {1902
OZ (generator_.generate_update_package_changed_info(s, package_id, var_idx));
1909
int ObPLCodeGenerateVisitor::visit(const ObPLTrimStmt &s)
1911
int ret = OB_SUCCESS;
1912
if (NULL == generator_.get_current().get_v()) {1914
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1915
LOG_WARN("failed to set insert point", K(ret));1916
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1917
LOG_WARN("failed to generate goto label", K(ret));1919
COLLECTION_STMT_COMM(s.get_trim_expr());
1922
ObLLVMValue int_value;
1923
ObSEArray<ObLLVMValue, 4> args;
1924
ObLLVMValue ret_err;
1925
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1926
OZ (generator_.generate_pointer(generator_.get_expr(s.get_trim()), int_value));
1927
OZ (args.push_back(int_value));
1928
OZ (generator_.get_helper().get_int64(row_size, int_value));
1929
OZ (args.push_back(int_value));
1930
OZ (generator_.generate_pointer(generator_.get_expr(s.get_n()), int_value));
1931
OZ (args.push_back(int_value));
1933
OZ (generator_.get_helper().create_call(ObString("spi_trim_collection"),1934
generator_.get_spi_service().spi_trim_collection_, args, ret_err));
1935
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
1936
s.get_block()->in_notfound(), s.get_block()->in_warning()));
1938
if (OB_SUCC(ret) && package_id != OB_INVALID_ID && var_idx != OB_INVALID_ID) {1939
OZ (generator_.generate_update_package_changed_info(s, package_id, var_idx));
1945
int ObPLCodeGenerateVisitor::visit(const ObPLDeleteStmt &s)
1947
int ret = OB_SUCCESS;
1948
if (NULL == generator_.get_current().get_v()) {1950
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1951
LOG_WARN("failed to set insert point", K(ret));1952
} else if (OB_FAIL(generator_.generate_goto_label(s))) {1953
LOG_WARN("failed to generate goto label", K(ret));1955
COLLECTION_STMT_COMM(s.get_delete_expr());
1958
ObLLVMValue int_value;
1959
ObSEArray<ObLLVMValue, 5> args;
1960
ObLLVMValue ret_err;
1961
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
1962
OZ (generator_.generate_pointer(generator_.get_expr(s.get_delete()), int_value));
1963
OZ (args.push_back(int_value));
1964
OZ (generator_.get_helper().get_int64(row_size, int_value));
1965
OZ (args.push_back(int_value));
1966
OZ (generator_.generate_pointer(generator_.get_expr(s.get_m()), int_value));
1967
OZ (args.push_back(int_value));
1968
OZ (generator_.generate_pointer(generator_.get_expr(s.get_n()), int_value));
1969
OZ (args.push_back(int_value));
1971
OZ (generator_.get_helper().create_call(ObString("spi_delete_collection"),1972
generator_.get_spi_service().spi_delete_collection_, args, ret_err));
1973
OZ (generator_.check_success(ret_err, s.get_stmt_id(),
1974
s.get_block()->in_notfound(), s.get_block()->in_warning()));
1976
if (OB_SUCC(ret) && package_id != OB_INVALID_ID && var_idx != OB_INVALID_ID) {1977
OZ (generator_.generate_update_package_changed_info(s, package_id, var_idx));
1983
#undef COLLECTION_STMT_COMM
1985
int ObPLCodeGenerateVisitor::visit(const ObPLDeclareCondStmt &s)
1987
int ret = OB_SUCCESS;
1993
int ObPLCodeGenerateVisitor::visit(const ObPLDeclareHandlerStmt &s)
1995
int ret = OB_SUCCESS;
1996
if (NULL == generator_.get_current().get_v()) {1998
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {1999
LOG_WARN("failed to set insert point", K(ret));2000
} else if (OB_FAIL(generator_.set_debug_location(s))) {2001
LOG_WARN("failed to set debug location", K(ret));2002
} else if (OB_FAIL(generator_.generate_goto_label(s))) {2003
LOG_WARN("failed to generate goto label", K(ret));2005
ObLLVMBasicBlock exception;
2006
ObLLVMBasicBlock body;
2007
ObLLVMLandingPad catch_result;
2008
ObLLVMType landingpad_type;
2009
ObLLVMValue int_value;
2011
if (OB_FAIL(generator_.get_helper().create_block(ObString("exception"), generator_.get_func(), exception))) {2012
LOG_WARN("failed to create block", K(ret));2013
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("body"), generator_.get_func(), body))) {2014
LOG_WARN("failed to create block", K(ret));2015
} else if (OB_FAIL(generator_.get_helper().create_br(body))) {2016
LOG_WARN("failed to create_br", K(ret));2017
} else if (OB_FAIL(generator_.get_helper().set_insert_point(exception))) {2018
LOG_WARN("failed to set_insert_point", K(ret));2019
} else if (OB_FAIL(generator_.get_adt_service().get_landingpad_result(landingpad_type))) {2020
LOG_WARN("failed to get_landingpad_result", K(ret));2021
} else if (OB_FAIL(generator_.get_helper().create_landingpad(ObString("landingPad"), landingpad_type, catch_result))) {2022
LOG_WARN("failed to create_landingpad", K(ret));2023
} else if (OB_FAIL(catch_result.set_cleanup())) {2024
LOG_WARN("failed to set_cleanup", K(ret));2026
} else if (OB_FAIL(generator_.get_helper().get_int64(3333, int_value))) {2027
LOG_WARN("failed to get_int64", K(ret));2028
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), int_value))) {2029
LOG_WARN("failed to create_call", K(ret));2032
common::ObArray<ObLLVMGlobalVariable> condition_clauses;
2033
common::ObArray<std::pair<ObPLConditionType, int64_t>> precedences;
2035
ObSEArray<ObLLVMValue, 8> condition_elements;
2036
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_handlers().count(); ++i) {2037
if (OB_ISNULL(s.get_handler(i).get_desc())) {2038
ret = OB_ERR_UNEXPECTED;
2039
LOG_WARN("handler is NULL", K(i), K(s.get_handler(i)), K(ret));2041
ObSqlString const_name;
2042
for (int64_t j = 0; OB_SUCC(ret) && j < s.get_handler(i).get_desc()->get_conditions().count(); ++j) {2044
condition_elements.reset();
2045
if (OB_FAIL(generator_.get_helper().get_int64(s.get_handler(i).get_desc()->get_condition(j).type_, int_value))) {2046
LOG_WARN("failed to get_int64", K(ret));2047
} else if (OB_FAIL(condition_elements.push_back(int_value))) {2048
LOG_WARN("push_back error", K(ret));2049
} else if (s.get_handler(i).get_desc()->get_condition(j).type_ >= MAX_TYPE) {2050
ret = OB_ERR_UNEXPECTED;
2051
LOG_WARN("type value error", K(ret));2052
} else if (OB_FAIL(const_name.append(ConditionType[s.get_handler(i).get_desc()->get_condition(j).type_]))) {2053
LOG_WARN("append error", K(ret));2054
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_handler(i).get_desc()->get_condition(j).error_code_, int_value))) {2055
LOG_WARN("failed to get_int64", K(ret));2056
} else if (OB_FAIL(condition_elements.push_back(int_value))) {2057
LOG_WARN("push_back error", K(ret));2058
} else if (OB_FAIL(const_name.append_fmt("%ld%ld", s.get_handler(i).get_level(), s.get_handler(i).get_desc()->get_condition(j).error_code_))) {2059
LOG_WARN("append_fmt error", K(ret));2061
ObLLVMValue elem_value;
2062
if (NULL == s.get_handler(i).get_desc()->get_condition(j).sql_state_ || 0 == s.get_handler(i).get_desc()->get_condition(j).str_len_) {2065
if (OB_FAIL(generator_.generate_empty_string(str, len))) {2066
LOG_WARN("failed to generate_empty_string", K(ret));2067
} else if (OB_FAIL(condition_elements.push_back(str))) {2068
LOG_WARN("push_back error", K(ret));2069
} else if (OB_FAIL(condition_elements.push_back(len))) {2070
LOG_WARN("push_back error", K(ret));2071
} else { /*do nothing*/ }2073
if (OB_FAIL(generator_.get_helper().create_global_string(ObString(s.get_handler(i).get_desc()->get_condition(j).str_len_, s.get_handler(i).get_desc()->get_condition(j).sql_state_), elem_value))) {2074
LOG_WARN("failed to create_global_string", K(ret));2075
} else if (OB_FAIL(condition_elements.push_back(elem_value))) {2076
LOG_WARN("push_back error", K(ret));2077
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_handler(i).get_desc()->get_condition(j).str_len_, int_value))) {2078
LOG_WARN("failed to get int64", K(ret));2079
} else if (OB_FAIL(condition_elements.push_back(int_value))) {2080
LOG_WARN("push_back error", K(ret));2081
} else if (OB_FAIL(const_name.append(s.get_handler(i).get_desc()->get_condition(j).sql_state_, s.get_handler(i).get_desc()->get_condition(j).str_len_))) {2082
LOG_WARN("append error", K(ret));2083
} else { /*do nothing*/ }2087
ObLLVMType llvm_type;
2088
ObLLVMConstant const_value;
2089
ObLLVMGlobalVariable const_condition;
2090
ObLLVMType condition_value_type;
2091
if (OB_FAIL(generator_.get_helper().get_int64(s.get_handler(i).get_level(), elem_value))) { //level(stmt_id)2092
LOG_WARN("failed to get int64", K(ret));2093
} else if (OB_FAIL(condition_elements.push_back(elem_value))) {2094
LOG_WARN("push_back error", K(ret));2095
} else if (OB_FAIL(generator_.generate_null(ObTinyIntType, elem_value))) { //signal2096
LOG_WARN("failed to get_llvm_type", K(ret));2097
} else if (OB_FAIL(condition_elements.push_back(elem_value))) {2098
LOG_WARN("push_back error", K(ret));2099
} else if (OB_FAIL(generator_.get_adt_service().get_pl_condition_value(condition_value_type))) {2100
LOG_WARN("failed to get_pl_condition_value", K(ret));2101
} else if (OB_FAIL(generator_.get_helper().get_or_insert_global(ObString(const_name.length(), const_name.ptr()), condition_value_type, const_condition))) {2102
LOG_WARN("failed to get_or_insert_global", K(ret));2103
} else if (OB_FAIL(ObLLVMHelper::get_const_struct(condition_value_type, condition_elements, const_value))) {2104
LOG_WARN("failed to get_const_struct", K(ret));2105
} else if (OB_FAIL(const_condition.set_initializer(const_value))) {2106
LOG_WARN("failed to set_initializer", K(ret));2107
} else if (OB_FAIL(const_condition.set_constant())) {2108
LOG_WARN("failed to set_constant", K(ret));2109
} else if (OB_FAIL(condition_clauses.push_back(const_condition))) {2110
LOG_WARN("failed to add_clause", K(ret));2111
} else if (OB_FAIL(precedences.push_back(std::make_pair(s.get_handler(i).get_desc()->get_condition(j).type_, s.get_handler(i).get_level())))) {2112
LOG_WARN("push back error", K(ret));2113
} else { /*do nothing*/ }2120
common::ObArray<int64_t> position_map;
2121
int64_t pos = OB_INVALID_INDEX;
2122
for (int64_t i = 0; OB_SUCC(ret) && i < precedences.count(); ++i) {2123
if (OB_FAIL(find_next_procedence_condition(precedences, position_map, pos))) {2124
LOG_WARN("failed to find next condition", K(ret));2125
} else if (OB_INVALID_INDEX == pos) {2126
ret = OB_ERR_UNEXPECTED;
2127
LOG_WARN("pos is invalid", K(ret), K(pos));2128
} else if (OB_FAIL(catch_result.add_clause(condition_clauses.at(pos)))) {2129
LOG_WARN("failed to add clause", K(ret));2130
} else if (OB_FAIL(position_map.push_back(pos))) {2131
LOG_WARN("push back error", K(ret));2137
common::ObArray<int64_t> tmp_array;
2138
for (int64_t i = 0; OB_SUCC(ret) && i < position_map.count(); ++i) {2140
for (int64_t j = 0; OB_SUCC(ret) && !find && j < position_map.count(); ++j) {2141
if (i == position_map.at(j)) {2142
if (OB_FAIL(tmp_array.push_back(j))) {2143
LOG_WARN("push back error", K(ret));2150
if (FAILEDx(position_map.assign(tmp_array))) {2151
LOG_WARN("assign error", K(ret));2156
ObLLVMValue unwindException;
2157
ObLLVMValue retTypeInfoIndex;
2158
ObLLVMValue unwindException_header;
2159
ObLLVMType condition_type;
2160
ObLLVMType condition_pointer_type;
2161
ObLLVMValue condition;
2163
if (OB_FAIL(generator_.get_helper().create_extract_value(ObString("extract_unwind_exception"), catch_result, 0, unwindException))) {2164
LOG_WARN("failed to create_extract_value", K(ret));2165
} else if (OB_FAIL(generator_.get_helper().create_extract_value(ObString("extract_ret_type_info_index"), catch_result, 1, retTypeInfoIndex))) {2166
LOG_WARN("failed to create_extract_value", K(ret));2167
} else if (OB_FAIL(generator_.get_helper().create_const_gep1_64(ObString("extract_unwind_exception_header"), unwindException, generator_.get_eh_service().pl_exception_base_offset_, unwindException_header))) {2168
LOG_WARN("failed to create_const_gep1_64", K(ret));2169
} else if (OB_FAIL(generator_.get_adt_service().get_pl_condition_value(condition_type))) {2170
LOG_WARN("failed to get_pl_condition_value", K(ret));2171
} else if (OB_FAIL(condition_type.get_pointer_to(condition_pointer_type))) {2172
LOG_WARN("failed to get_pointer_to", K(ret));2173
} else if (OB_FAIL(generator_.get_helper().create_pointer_cast(ObString("cast_header"), unwindException_header, condition_pointer_type, condition))) {2174
LOG_WARN("failed to create_pointer_cast", K(ret));2179
ObLLVMValue stmt_id;
2181
if (OB_FAIL(generator_.extract_type_from_condition_value(condition, type))) {2182
LOG_WARN("failed to extract_type_from_condition_value", K(ret));2183
} else if (OB_FAIL(generator_.extract_code_from_condition_value(condition, code))) {2184
LOG_WARN("failed to extract_code_from_condition_value", K(ret));2185
} else if (OB_FAIL(generator_.extract_name_from_condition_value(condition, name))) {2186
LOG_WARN("failed to extract_name_from_condition_value", K(ret));2187
} else if (OB_FAIL(generator_.extract_stmt_from_condition_value(condition, stmt_id))) {2188
LOG_WARN("failed to extract_stmt_from_condition_value", K(ret));2189
} else if (OB_FAIL(generator_.extract_signal_from_condition_value(condition, signal))) {2190
LOG_WARN("failed to extract_signal_from_condition_value", K(ret));2192
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), unwindException))) {2193
LOG_WARN("failed to create_call", K(ret));2194
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), retTypeInfoIndex))) {2195
LOG_WARN("failed to create_call", K(ret));2196
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), type))) {2197
LOG_WARN("failed to create_call", K(ret));2198
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), code))) {2199
LOG_WARN("failed to create_call", K(ret));2200
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), name))) {2201
LOG_WARN("failed to create_call", K(ret));2202
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), stmt_id))) {2203
LOG_WARN("failed to create_call", K(ret));2205
} else { /*do nothing*/ }2209
ObLLVMBasicBlock resume_handler;
2210
ObLLVMBasicBlock exit_handler;
2212
if (OB_FAIL(generator_.get_helper().create_block(ObString("resume_handler"), generator_.get_func(), resume_handler))) {2213
LOG_WARN("failed to create block", K(ret));2214
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("exit_handler"), generator_.get_func(), exit_handler))) {2215
LOG_WARN("failed to create block", K(ret));2216
} else { /*do nothing*/ }2219
ObLLVMSwitch switch_inst;
2220
if (OB_FAIL(generator_.get_helper().create_switch(retTypeInfoIndex, resume_handler, switch_inst))) {2221
LOG_WARN("failed to create switch", K(ret));2224
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_handlers().count(); ++i) {2225
ObLLVMBasicBlock case_branch;
2226
if (OB_FAIL(generator_.get_helper().create_block(ObString("case"), generator_.get_func(), case_branch))) {2227
LOG_WARN("failed to create block", K(ret));2229
for (int64_t j = 0; OB_SUCC(ret) && j < s.get_handler(i).get_desc()->get_conditions().count(); ++j) {2230
if (OB_FAIL(generator_.get_helper().get_int32(position_map.at(index++) + 1, int_value))) {2231
LOG_WARN("failed to get int32", K(ret));2232
} else if (OB_FAIL(switch_inst.add_case(int_value, case_branch))) {2233
LOG_WARN("failed to add_case", K(ret));2234
} else { /*do nothing*/ }2238
* 如果捕捉到了该exception，处理完body后，视handler的ACTION和level决定下一个目的地：
2240
* CONTINUE：跳到抛出exception的语句的下一句
2241
* 我们对Handler做了改写，所以这里的逻辑是：
2243
* 下降的CONTINUE：跳出当前block
2247
if (NULL == s.get_handler(i).get_desc()->get_body() || (s.get_handler(i).get_desc()->is_exit() && !s.get_handler(i).is_original())) { //下降的EXIT，不执行body2248
if (OB_FAIL(generator_.get_helper().set_insert_point(case_branch))) {2249
LOG_WARN("failed to set_insert_point", K(ret));2250
} else if (OB_FAIL(generator_.get_helper().create_br(s.get_handler(i).get_desc()->is_exit() && !s.get_handler(i).is_original() ? resume_handler : exit_handler))) {2251
LOG_WARN("failed to create_br", K(ret));2252
} else { /*do nothing*/ }2254
ObLLVMValue p_status, status;
2255
ObLLVMBasicBlock current = generator_.get_current();
2256
ObLLVMValue old_exception, old_ob_error;
2257
ObSEArray<ObLLVMValue, 2> args;
2259
ObLLVMValue p_old_sqlcode, is_need_pop_warning_buf;
2260
ObLLVMType int_type;
2261
OZ (generator_.set_current(case_branch));
2263
OZ (generator_.get_helper().get_int64(1111+i, int_value));
2264
OZ (generator_.generate_debug(ObString("debug"), int_value));2266
OZ (generator_.get_helper().get_int32(OB_SUCCESS, int_value));
2267
OZ (generator_.get_helper().create_store(int_value, generator_.get_vars().at(generator_.RET_IDX)));
2268
OZ (generator_.extract_status_from_context(generator_.get_vars().at(generator_.CTX_IDX), p_status));
2269
OZ (generator_.get_helper().create_load(ObString("load status"), p_status, status));2270
OZ (generator_.get_helper().create_store(int_value, p_status));
2272
// 记录下当前捕获到的ObError, 用于设置再次抛出该异常时设置status
2273
OX (old_ob_error = generator_.get_saved_ob_error());
2274
OX (generator_.get_saved_ob_error() = status);
2277
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
2278
OZ (generator_.get_helper().create_alloca(ObString("old_sqlcode"), int_type, p_old_sqlcode));2279
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2280
OZ (args.push_back(p_old_sqlcode));
2281
OZ (generator_.get_helper().create_call(ObString("spi_get_pl_exception_code"), generator_.get_spi_service().spi_get_pl_exception_code_, args, result));2282
OZ (generator_.check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2284
// 记录下当前捕获到的Exception, 用于SIGNAL语句抛出当前异常
2285
OX (old_exception = generator_.get_saved_exception());
2286
OX (generator_.get_saved_exception() = unwindException);
2288
// 设置当前ExceptionCode到SQLCODE
2290
OZ (generator_.get_helper().get_int8(false, is_need_pop_warning_buf));
2291
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2292
OZ (args.push_back(code));
2293
OZ (args.push_back(is_need_pop_warning_buf));
2294
OZ (generator_.get_helper().create_call(ObString("spi_set_pl_exception_code"), generator_.get_spi_service().spi_set_pl_exception_code_, args, result));2295
OZ (generator_.check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2298
// Check当前是否是嵌套事务的ExceptionHandler, 失效掉嵌套事务内部的Exception Handler
2300
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2301
OZ (args.push_back(code));
2302
OZ (generator_.get_helper().create_call(
2303
ObString("spi_check_exception_handler_legal"),2304
generator_.get_spi_service().spi_check_exception_handler_legal_,
2307
OZ (generator_.check_success(
2310
s.get_block()->in_notfound(),
2311
s.get_block()->in_warning()));
2314
// Codegen当前Handler的Body
2315
OZ (SMART_CALL(generate(*s.get_handler(i).get_desc()->get_body())));
2318
OX (generator_.get_saved_exception() = old_exception);
2319
OX (generator_.get_saved_ob_error() = old_ob_error);
2323
&& OB_NOT_NULL(generator_.get_current().get_v())) {2324
ObLLVMValue old_code;
2325
if (OB_ISNULL(old_exception.get_v())) {2326
OZ (generator_.get_helper().create_load(ObString("load_old_sqlcode"), p_old_sqlcode, old_code));2327
OZ (generator_.generate_debug(ObString("debug"), int_value));2328
//OZ (generator_.get_helper().get_int64(OB_SUCCESS, old_code));
2330
ObLLVMValue old_unwindException_header;
2331
ObLLVMType old_condition_type;
2332
ObLLVMType old_condition_pointer_type;
2333
ObLLVMValue old_condition;
2334
OZ (generator_.get_helper().create_const_gep1_64(ObString("extract_unwind_exception_header"), unwindException, generator_.get_eh_service().pl_exception_base_offset_, old_unwindException_header));2335
OZ (generator_.get_adt_service().get_pl_condition_value(old_condition_type));
2336
OZ (condition_type.get_pointer_to(old_condition_pointer_type));
2337
OZ (generator_.get_helper().create_pointer_cast(ObString("cast_header"), old_unwindException_header, old_condition_pointer_type, old_condition));2338
OZ (generator_.extract_code_from_condition_value(old_condition, old_code));
2341
OZ (generator_.get_helper().get_int8(true, is_need_pop_warning_buf));
2342
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2343
OZ (args.push_back(old_code));
2344
OZ (args.push_back(is_need_pop_warning_buf));
2345
OZ (generator_.get_helper().create_call(ObString("spi_set_pl_exception_code"), generator_.get_spi_service().spi_set_pl_exception_code_, args, result));2346
OZ (generator_.check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2348
OZ (generator_.finish_current(s.get_handler(i).get_desc()->is_exit() && !s.get_handler(i).is_original() ? resume_handler : exit_handler)); //下降的EXIT才抛出
2349
OZ (generator_.set_current(current));
2356
ObLLVMType unwind_exception_type;
2357
ObLLVMType unwind_exception_pointer_type;
2358
if (OB_FAIL(generator_.set_exception(exception,
2360
s.get_level()))) { //这里才可以压栈exception2361
LOG_WARN("failed to set_exception", K(ret));2362
} else if (OB_FAIL(generator_.get_helper().set_insert_point(resume_handler))) {2363
LOG_WARN("failed to set_insert_point", K(ret));2364
} else if (NULL != generator_.get_parent_exception()) {2366
if (OB_FAIL(generator_.get_helper().get_int64(2222, int_value))) {2367
LOG_WARN("failed to get int64", K(ret));2368
} else if (OB_FAIL(generator_.generate_debug(ObString("debug"), int_value))) {2369
LOG_WARN("failed to create_call", K(ret));2372
if (OB_FAIL(generator_.get_adt_service().get_unwind_exception(unwind_exception_type))) {2373
LOG_WARN("failed to get_unwind_exception", K(ret));2374
} else if (OB_FAIL(unwind_exception_type.get_pointer_to(unwind_exception_pointer_type))) {2375
LOG_WARN("failed to get_pointer_to", K(ret));2376
} else if (OB_FAIL(generator_.get_helper().create_pointer_cast(ObString("cast_unwind_exception"), unwindException, unwind_exception_pointer_type, unwindException))) {2377
LOG_WARN("failed to create_pointer_cast", K(ret));2378
} else if (OB_FAIL(generator_.get_helper().create_invoke(ObString("call_resume"), generator_.get_eh_service().eh_resume_, unwindException, body, generator_.get_parent_exception()->exception_))) {2379
LOG_WARN("failed to create block", K(ret));2380
} else { /*do nothing*/ }2382
if (OB_FAIL(generator_.get_helper().create_resume(catch_result))) {2383
LOG_WARN("failed to create_resume", K(ret));2389
if (OB_FAIL(generator_.set_current(body))) {2390
LOG_WARN("failed to set_current", K(ret));2403
int ObPLCodeGenerateVisitor::visit(const ObPLSignalStmt &s)
2405
int ret = OB_SUCCESS;
2406
if (NULL == generator_.get_current().get_v()) {2409
OZ (generator_.get_helper().set_insert_point(generator_.get_current()));
2410
OZ (generator_.set_debug_location(s));
2411
OZ (generator_.generate_goto_label(s));
2413
ObLLVMBasicBlock normal;
2414
ObLLVMType unwind_exception_type, unwind_exception_pointer_type;
2415
ObLLVMType condition_type;
2416
ObLLVMType condition_pointer_type;
2417
ObLLVMValue unwindException = generator_.get_saved_exception();
2418
ObLLVMValue ob_error_code = generator_.get_saved_ob_error();
2419
ObLLVMValue unwind_exception_header;
2420
ObLLVMValue condition;
2421
ObLLVMValue sql_state;
2422
ObLLVMValue error_code;
2423
OZ (generator_.get_adt_service().get_unwind_exception(unwind_exception_type));
2424
OZ (unwind_exception_type.get_pointer_to(unwind_exception_pointer_type));
2425
OZ (generator_.get_adt_service().get_pl_condition_value(condition_type));
2426
OZ (condition_type.get_pointer_to(condition_pointer_type));
2428
} else if (s.is_signal_null()) {2430
CK (OB_NOT_NULL(generator_.get_saved_exception().get_v()));
2431
CK (OB_NOT_NULL(generator_.get_saved_ob_error().get_v()));
2432
OZ (generator_.extract_status_from_context(generator_.get_vars().at(generator_.CTX_IDX), status));
2433
OZ (generator_.get_helper().create_store(ob_error_code, status));
2434
OZ (generator_.get_helper().create_const_gep1_64(ObString("extract_unwind_exception_header"),2436
generator_.get_eh_service().pl_exception_base_offset_,
2437
unwind_exception_header));
2438
OZ (generator_.get_helper().create_pointer_cast(ObString("cast_header"),2439
unwind_exception_header,
2440
condition_pointer_type,
2442
OZ (generator_.extract_name_from_condition_value(condition, sql_state));
2443
OZ (generator_.extract_code_from_condition_value(condition, error_code));
2444
OZ (generator_.get_helper().create_pointer_cast(
2445
ObString("cast_unwind_exception"), unwindException,2446
unwind_exception_pointer_type, unwindException));
2447
OZ (generator_.get_helper().create_block(ObString("normal"), generator_.get_func(), normal));2448
OZ (generator_.raise_exception(unwindException, error_code, sql_state, normal,
2449
s.get_block()->in_notfound(), s.get_block()->in_warning(), true));
2450
OZ (generator_.set_current(normal));
2452
ObLLVMValue type, ob_err_code, err_code, sql_state, str_len, is_signal, stmt_id, loc, err_code_ptr;
2453
if (lib::is_mysql_mode() && (s.is_resignal_stmt() || s.get_cond_type() != ERROR_CODE)) {2454
ObLLVMValue int_value;
2455
ObLLVMType int_type, int32_type, int32_type_ptr;
2456
ObSEArray<ObLLVMValue, 5> args;
2458
int64_t *err_idx = const_cast<int64_t *>(s.get_expr_idx(
2459
static_cast<int64_t>(SignalCondInfoItem::DIAG_MYSQL_ERRNO)));
2460
int64_t *msg_idx = const_cast<int64_t *>(s.get_expr_idx(
2461
static_cast<int64_t>(SignalCondInfoItem::DIAG_MESSAGE_TEXT)));
2462
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
2463
OZ (generator_.get_helper().get_llvm_type(ObInt32Type, int32_type));
2464
OZ (int32_type.get_pointer_to(int32_type_ptr));
2465
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2466
OZ (generator_.generate_pointer(NULL != err_idx ? generator_.get_expr(*err_idx) : NULL, int_value));
2467
OZ (args.push_back(int_value));
2468
OZ (generator_.generate_pointer(NULL != msg_idx ? generator_.get_expr(*msg_idx) : NULL, int_value));
2469
OZ (args.push_back(int_value));
2470
OZ (generator_.generate_string(ObString(s.get_str_len(), s.get_sql_state()), sql_state, str_len));
2471
OZ (args.push_back(sql_state));
2472
OZ (generator_.get_helper().create_alloca(ObString("error_code"), int_type, err_code_ptr));2473
if (s.is_resignal_stmt()) {2474
// ObLLVMValue code_ptr;
2475
CK (OB_NOT_NULL(generator_.get_saved_exception().get_v()));
2476
CK (OB_NOT_NULL(generator_.get_saved_ob_error().get_v()));
2477
OZ (generator_.get_helper().create_const_gep1_64(ObString("extract_unwind_exception_header"),2479
generator_.get_eh_service().pl_exception_base_offset_,
2480
unwind_exception_header));
2481
OZ (generator_.get_helper().create_pointer_cast(ObString("cast_header"),2482
unwind_exception_header,
2483
condition_pointer_type,
2485
OZ (generator_.extract_name_from_condition_value(condition, sql_state));
2486
OZ (generator_.extract_code_from_condition_value(condition, error_code));
2487
OZ (generator_.get_helper().create_store(error_code, err_code_ptr));
2489
OZ (generator_.get_helper().get_int64(OB_SUCCESS, err_code));
2490
OZ (generator_.get_helper().create_store(err_code, err_code_ptr));
2492
OZ (args.push_back(err_code_ptr));
2493
OZ (args.push_back(sql_state));
2494
OZ (generator_.get_helper().get_int8(!s.is_resignal_stmt(), is_signal));
2495
OZ (args.push_back(is_signal));
2496
OZ (generator_.get_helper().create_call(ObString("spi_process_resignal"),2497
generator_.get_spi_service().spi_process_resignal_error_,
2500
OZ (generator_.check_success(ob_err_code, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2501
OZ (generator_.get_helper().create_load(ObString("load_error_code"), err_code_ptr, err_code));2502
OZ (generator_.get_helper().create_bit_cast(ObString("cast_int64_to_int32"), err_code_ptr, int32_type_ptr, err_code_ptr));2503
OZ (generator_.get_helper().create_load(ObString("load_error_code"), err_code_ptr, ob_err_code));2505
OZ (generator_.get_helper().get_int32(s.get_ob_error_code(), ob_err_code));
2506
OZ (generator_.get_helper().get_int64(s.get_error_code(), err_code));
2508
OZ (generator_.get_helper().get_int64(s.get_cond_type(), type));
2509
OZ (generator_.get_helper().create_block(ObString("normal"), generator_.get_func(), normal));2510
OZ (generator_.generate_string(ObString(s.get_str_len(), s.get_sql_state()), sql_state, str_len));
2511
OZ (generator_.get_helper().get_int64(s.get_stmt_id(), stmt_id));
2512
// 暂时先用stmtid， 这个id就是col和line的组合
2513
OZ (generator_.get_helper().get_int64(s.get_stmt_id(), loc));
2514
OZ (generator_.generate_exception(type, ob_err_code, err_code, sql_state, str_len, stmt_id,
2515
normal, loc, s.get_block()->in_notfound(),
2516
s.get_block()->in_warning(), true/*is signal*/));
2517
OZ (generator_.set_current(normal));
2523
int ObPLCodeGenerateVisitor::visit(const ObPLRaiseAppErrorStmt &s)
2525
int ret = OB_SUCCESS;
2526
if (NULL == generator_.get_current().get_v()) {2528
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {2529
LOG_WARN("failed to set insert point", K(ret));2530
} else if (OB_FAIL(generator_.set_debug_location(s))) {2531
LOG_WARN("failed to set debug location", K(ret));2532
} else if (OB_FAIL(generator_.generate_goto_label(s))) {2533
LOG_WARN("failed to generate goto label", K(ret));2535
ObLLVMValue int_value;
2536
ObSEArray<ObLLVMValue, 3> args;
2537
ObLLVMValue ret_err;
2538
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2539
OZ (generator_.generate_pointer(generator_.get_expr(s.get_params().at(0)), int_value));
2540
OZ (args.push_back(int_value));
2541
OZ (generator_.generate_pointer(generator_.get_expr(s.get_params().at(1)), int_value));
2542
OZ (args.push_back(int_value));
2543
OZ (generator_.get_helper().create_call(ObString("spi_raise_application_error"), generator_.get_spi_service().spi_raise_application_error_, args, ret_err));2544
OZ (generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2549
int ObPLCodeGenerateVisitor::visit(const ObPLCallStmt &s)
2551
int ret = OB_SUCCESS;
2552
if (NULL == generator_.get_current().get_v()) {2554
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {2555
LOG_WARN("failed to set insert point", K(ret));2556
} else if (OB_FAIL(generator_.set_debug_location(s))) {2557
LOG_WARN("failed to set debug location", K(ret));2558
} else if (OB_FAIL(generator_.generate_goto_label(s))) {2559
LOG_WARN("failed to generate goto label", K(ret));2562
ObLLVMType argv_type;
2563
ObLLVMType int_type;
2564
if (OB_FAIL(generator_.get_helper().get_llvm_type(ObIntType, int_type))) {2565
LOG_WARN("failed to get_llvm_type", K(ret));2566
} else if (OB_FAIL(generator_.get_adt_service().get_argv(s.get_params().count(), argv_type))) {2567
LOG_WARN("failed to get argv type", K(ret));2568
} else if (OB_FAIL(generator_.get_helper().create_alloca(ObString("inner_pl_argv"), argv_type, params))) {2569
LOG_WARN("failed to create_alloca", K(ret));2571
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_params().count(); ++i) {2573
ObLLVMValue p_result_obj;
2574
if (s.is_pure_out(i)) {2575
const ObPLVar *var =
2576
OB_INVALID_INDEX == s.get_out_index(i) ? NULL : s.get_variable(s.get_out_index(i));
2577
const ObPLDataType *pl_type = OB_ISNULL(var) ? NULL : &(var->get_type());
2578
ObPLDataType final_type;
2579
if (lib::is_oracle_mode() && NULL != var && var->get_type().is_cursor_type()) {2580
OZ (generator_.extract_objparam_from_context(generator_.get_vars().at(
2581
generator_.CTX_IDX),
2585
OZ (generator_.generate_new_objparam(p_result_obj), K(i), KPC(var));
2588
&& OB_ISNULL(pl_type)
2589
&& OB_NOT_NULL(s.get_param_expr(i))
2590
&& s.get_param_expr(i)->is_obj_access_expr()) {2591
const ObObjAccessRawExpr *obj_access
2592
= static_cast<const ObObjAccessRawExpr *>(s.get_param_expr(i));
2593
CK (OB_NOT_NULL(obj_access));
2594
OZ (obj_access->get_final_type(final_type));
2595
OX (pl_type = &final_type);
2598
&& OB_NOT_NULL(pl_type)
2599
&& pl_type->is_composite_type()
2600
&& !pl_type->is_opaque_type()) { // 普通类型构造空的ObjParam即可,复杂类型需要构造对应的指针2603
ObLLVMValue const_value;
2604
if (OB_FAIL(generator_.get_llvm_type(*pl_type, ir_type))) {2605
LOG_WARN("failed to get llvm type", K(ret));2607
generator_.get_helper().create_alloca(ObString("PureOut"), ir_type, value))) {2608
LOG_WARN("failed to create alloca", K(ret));2609
} else if (OB_FAIL(pl_type->generate_construct(generator_,
2613
LOG_WARN("failed to generate_construct", K(ret));2614
} else if (pl_type->is_collection_type()) {2615
const ObUserDefinedType *user_type = NULL;
2616
if (OB_ISNULL(s.get_namespace())) {2617
ret = OB_ERR_UNEXPECTED;
2618
LOG_WARN("ns is NULL", K(ret));2619
} else if (OB_FAIL(s.get_namespace()
2620
->get_pl_data_type_by_id(pl_type->get_user_type_id(), user_type))) {2621
LOG_WARN("failed to get pl data type by id", K(ret));2622
} else if (OB_ISNULL(user_type)) {2623
ret = OB_ERR_UNEXPECTED;
2624
LOG_WARN("user type is NULL", K(pl_type->get_user_type_id()), K(ret));2625
} else { /*do nothing*/ }2628
int64_t init_size = OB_INVALID_SIZE;
2629
ObLLVMValue p_dest_value;
2630
ObLLVMType int_type;
2631
ObLLVMValue var_addr;
2632
ObLLVMValue var_type;
2633
ObLLVMValue init_value;
2634
ObLLVMValue extend_value;
2635
OZ (generator_.get_helper().get_int8(pl_type->get_type(), var_type));
2636
OZ (pl_type->get_size(*s.get_namespace(), PL_TYPE_INIT_SIZE, init_size));
2637
OZ (generator_.get_helper().get_int32(init_size, init_value));
2638
OZ (generator_.get_helper().get_llvm_type(ObIntType, int_type));
2639
OZ (generator_.get_helper().create_ptr_to_int(ObString("cast_ptr_to_int64"),2643
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, p_dest_value));
2644
OZ (generator_.generate_set_extend(p_dest_value, var_type, init_value, var_addr));
2648
const ObPLVar *var = OB_INVALID_INDEX == s.get_out_index(i)
2649
? NULL : s.get_variable(s.get_out_index(i));
2650
if (lib::is_oracle_mode() && NULL != var && var->get_type().is_cursor_type()) {2651
OZ (generator_.extract_objparam_from_context(generator_.get_vars().at(
2652
generator_.CTX_IDX),
2655
} else if (!s.get_param_expr(i)->is_obj_access_expr()
2656
|| !(static_cast<const ObObjAccessRawExpr *>(s.get_param_expr(i)))->for_write()) {2657
OZ (generator_.generate_expr(s.get_param(i), s, OB_INVALID_INDEX, p_result_obj));
2659
ObLLVMValue address;
2660
ObPLDataType final_type;
2661
bool is_no_copy_param = s.get_nocopy_params().count() > 0 && OB_INVALID_INDEX != s.get_nocopy_params().at(i);
2662
const ObObjAccessRawExpr *obj_access
2663
= static_cast<const ObObjAccessRawExpr *>(s.get_param_expr(i));
2664
CK (OB_NOT_NULL(obj_access));
2665
OZ (obj_access->get_final_type(final_type));
2666
OZ (generator_.generate_expr(s.get_param(i),
2669
(final_type.is_obj_type() || !is_no_copy_param) ? address : p_result_obj));
2671
} else if (final_type.is_obj_type()) {2672
ObLLVMType obj_type;
2673
ObLLVMType obj_type_ptr;
2675
ObLLVMValue src_obj;
2676
ObLLVMValue p_dest_obj;
2677
OZ (generator_.generate_new_objparam(p_result_obj));
2678
OZ (generator_.extract_extend_from_objparam(address, final_type, p_obj));
2679
OZ (generator_.get_adt_service().get_obj(obj_type));
2680
OZ (obj_type.get_pointer_to(obj_type_ptr));
2681
OZ (generator_.get_helper().create_bit_cast(
2682
ObString("cast_addr_to_obj_ptr"), p_obj, obj_type_ptr, p_obj));2683
OZ (generator_.get_helper().create_load(ObString("load obj value"), p_obj, src_obj));2684
OZ (generator_.extract_datum_ptr_from_objparam(p_result_obj, ObNullType, p_dest_obj));
2685
OZ (generator_.get_helper().create_store(src_obj, p_dest_obj));
2686
} else if (!is_no_copy_param) {2687
ObLLVMValue allocator;
2688
ObLLVMValue src_datum;
2689
ObLLVMValue dest_datum;
2690
int64_t udt_id = s.get_param_expr(i)->get_result_type().get_udt_id();
2691
OZ (generator_.extract_allocator_from_context(
2692
generator_.get_vars().at(generator_.CTX_IDX), allocator));
2693
OZ (generator_.generate_new_objparam(p_result_obj, udt_id));
2694
OZ (generator_.extract_obobj_ptr_from_objparam(p_result_obj, dest_datum));
2695
OZ (generator_.extract_obobj_ptr_from_objparam(address, src_datum));
2696
OZ (final_type.generate_copy(generator_,
2701
s.get_block()->in_notfound(),
2702
s.get_block()->in_warning(),
2710
if (OB_FAIL(generator_.get_helper().create_ptr_to_int(ObString("cast_arg_to_pointer"), p_result_obj, int_type, p_arg))) {2711
LOG_WARN("failed to create_PtrToInt", K(ret));2712
} else if (OB_FAIL(generator_.extract_arg_from_argv(params, i, pp_arg))) {2713
LOG_WARN("failed to extract_arg_from_argv", K(ret));2714
} else if (OB_FAIL(generator_.get_helper().create_store(p_arg, pp_arg))) {2715
LOG_WARN("failed to create_store", K(ret));2716
} else { /*do nothing*/ }2721
ObSEArray<ObLLVMValue, 5> args;
2723
ObLLVMValue int_value;
2724
ObLLVMValue array_value;
2725
ObLLVMValue nocopy_array_value;
2726
uint64_t package_id = s.get_package_id();
2727
package_id = (1 == s.get_is_object_udf())
2728
? share::schema::ObUDTObjectType::mask_object_id(package_id) : package_id;
2729
if (OB_FAIL(args.push_back(generator_.get_vars().at(generator_.CTX_IDX)))) { //PL的执行环境2730
LOG_WARN("push_back error", K(ret));2731
} else if (OB_FAIL(generator_.get_helper().get_int64(package_id, int_value))) {2732
LOG_WARN("failed to get int64", K(ret));2733
} else if (OB_FAIL(args.push_back(int_value))) { //PL的package id2734
LOG_WARN("push_back error", K(ret));2735
}else if (OB_FAIL(generator_.get_helper().get_int64(s.get_proc_id(), int_value))) {2736
LOG_WARN("failed to get int64", K(ret));2737
} else if (OB_FAIL(args.push_back(int_value))) { //PL的proc id2738
LOG_WARN("push_back error", K(ret));2739
}else if (OB_FAIL(generator_.generate_int64_array(s.get_subprogram_path(), array_value))) {2740
LOG_WARN("failed to get int64", K(ret));2741
} else if (OB_FAIL(args.push_back(array_value))) { //PL的subprogram path2742
LOG_WARN("push_back error", K(ret));2743
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_subprogram_path().count(),
2745
LOG_WARN("failed to get int64", K(ret));2746
} else if (OB_FAIL(args.push_back(int_value))) { //subprogram path长度2747
LOG_WARN("push_back error", K(ret));2748
} else if (OB_FAIL(generator_.get_helper().get_int64(static_cast<uint64_t>(s.get_stmt_id()), int_value))) {2749
LOG_WARN("failed to get int64", K(ret));2750
} else if (OB_FAIL(args.push_back(int_value))) { // line number;2751
LOG_WARN("push back line number error", K(ret));2752
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_params().count(), int_value))) {2753
LOG_WARN("failed to get int64", K(ret));2754
} else if (OB_FAIL(args.push_back(int_value))) { //argc2755
LOG_WARN("push_back error", K(ret));2756
} else if (OB_FAIL(generator_.get_helper().create_ptr_to_int(ObString("cast_argv_to_pointer"), params, int_type, argv))) {2757
LOG_WARN("failed to create_PtrToInt", K(ret));2758
} else if (OB_FAIL(args.push_back(argv))) {//argv2759
LOG_WARN("push_back error", K(ret));2760
} else if (OB_FAIL(generator_.generate_int64_array(s.get_nocopy_params(),
2761
nocopy_array_value))) {2762
LOG_WARN("failed to get int64_t array", K(ret));2763
} else if (OB_FAIL(args.push_back(nocopy_array_value))) {2764
LOG_WARN("failed to push back", K(ret));2765
} else if (OB_FAIL(generator_.get_helper().get_int64(s.get_dblink_id(), int_value))) {2766
LOG_WARN("failed to get int64", K(ret));2767
} else if (OB_FAIL(args.push_back(int_value))) { //PL的dblink id2768
LOG_WARN("push_back error", K(ret));2771
if (NULL == generator_.get_current_exception()) {2772
if (OB_FAIL(generator_.get_helper().create_call(ObString("inner_pl_execute"), generator_.get_pl_execute(), args, result))) {2773
LOG_WARN("failed to create_call", K(ret));2775
OZ (generator_.generate_debug(ObString("debug inner pl execute"), result));2777
ObLLVMBasicBlock alter_inner_call;
2779
if (OB_FAIL(generator_.get_helper().create_block(ObString("alter_inner_call"), generator_.get_func(), alter_inner_call))) {2780
LOG_WARN("failed to create block", K(s), K(ret));2781
} else if (OB_FAIL(generator_.get_helper().create_invoke(ObString("inner_pl_execute"), generator_.get_pl_execute(), args, alter_inner_call, generator_.get_current_exception()->exception_, result))) {2782
LOG_WARN("failed to create_call", K(ret));2783
} else if (OB_FAIL(generator_.set_current(alter_inner_call))) {2784
LOG_WARN("failed to set_current", K(ret));2785
} else { /*do nothing*/ }2787
OZ (generator_.generate_debug(ObString("debug inner pl execute result"), result));2788
OZ (generator_.check_success(
2789
result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2790
OZ (generator_.generate_out_params(s, s.get_params(), params));
2798
int ObPLCodeGenerateVisitor::visit(const ObPLDeclareCursorStmt &s)
2800
return generator_.generate_declare_cursor(s, s.get_cursor_index());
2803
int ObPLCodeGenerateVisitor::visit(const ObPLOpenStmt &s)
2805
int ret = OB_SUCCESS;
2806
OZ (generator_.generate_goto_label(s));
2807
CK (OB_NOT_NULL(s.get_cursor()));
2808
OZ (generator_.generate_open(static_cast<const ObPLStmt&>(s),
2809
s.get_cursor()->get_value(),
2810
s.get_cursor()->get_package_id(),
2811
s.get_cursor()->get_routine_id(),
2816
int ObPLCodeGenerateVisitor::visit(const ObPLOpenForStmt &s)
2818
int ret = OB_SUCCESS;
2819
OZ (generator_.generate_goto_label(s));
2820
OZ (generator_.generate_open_for(s));
2824
int ObPLCodeGenerateVisitor::visit(const ObPLFetchStmt &s)
2826
int ret = OB_SUCCESS;
2827
ObLLVMValue ret_err;
2828
OZ (generator_.generate_goto_label(s));
2829
if (OB_FAIL(generator_.generate_fetch(static_cast<const ObPLStmt&>(s),
2830
static_cast<const ObPLInto&>(s),
2837
LOG_WARN("failed to generate fetch", K(ret));2838
} else if (lib::is_mysql_mode()) { //Mysql模式直接检查抛出异常2839
OZ (generator_.check_success(
2840
ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning(), true));
2841
} else { //Oracle模式如果是OB_READ_NOTHING错误，吞掉异常不抛出2842
ObLLVMValue is_not_found;
2843
ObLLVMBasicBlock fetch_end;
2844
ObLLVMBasicBlock fetch_check_success;
2845
if (OB_FAIL(generator_.get_helper().create_block(ObString("fetch_end"), generator_.get_func(), fetch_end))) {2846
LOG_WARN("failed to create block", K(s), K(ret));2847
} else if (OB_FAIL(generator_.get_helper().create_block(ObString("fetch_check_success"), generator_.get_func(), fetch_check_success))) {2848
LOG_WARN("failed to create block", K(s), K(ret));2849
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(ret_err, OB_READ_NOTHING, is_not_found))) {2850
LOG_WARN("failed to create_icmp_eq", K(ret));2851
} else if (OB_FAIL(generator_.get_helper().create_cond_br(is_not_found, fetch_end, fetch_check_success))) {2852
LOG_WARN("failed to create_cond_br", K(ret));2853
} else { /*do nothing*/ }2856
if (OB_FAIL(generator_.set_current(fetch_check_success))) {2857
LOG_WARN("failed to set current", K(ret));2858
} else if (OB_FAIL(generator_.check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {2859
LOG_WARN("failed to check success", K(ret));2860
} else if (OB_FAIL(generator_.get_helper().create_br(fetch_end))) {2861
LOG_WARN("failed to create_br", K(ret));2862
} else if (OB_FAIL(generator_.set_current(fetch_end))) {2863
LOG_WARN("failed to set current", K(ret));2864
} else { /*do nothing*/ }2868
if (OB_FAIL(generator_.generate_into_restore(s.get_into(), s.get_exprs(), s.get_symbol_table()))) {2869
LOG_WARN("Failed to generate_into", K(ret));2875
int ObPLCodeGenerateVisitor::visit(const ObPLCloseStmt &s)
2877
int ret = OB_SUCCESS;
2878
OZ (generator_.generate_goto_label(s));
2879
if (OB_FAIL(generator_.generate_close(static_cast<const ObPLStmt&>(s),
2883
LOG_WARN("failed to generate close", K(ret));2888
int ObPLCodeGenerateVisitor::visit(const ObPLNullStmt &s)
2890
int ret = OB_SUCCESS;
2891
if (NULL == generator_.get_current().get_v()) {2893
} else if (OB_FAIL(generator_.generate_goto_label(s))) {2894
LOG_WARN("failed to generate goto label", K(ret));2900
int ObPLCodeGenerateVisitor::visit(const ObPLPipeRowStmt &s)
2902
int ret = OB_SUCCESS;
2903
if (NULL == generator_.get_current().get_v()) {2906
OZ (generator_.get_helper().set_insert_point(generator_.get_current()));
2907
OZ (generator_.set_debug_location(s));
2908
OZ (generator_.generate_goto_label(s));
2910
ObLLVMBasicBlock pipe_row_block;
2911
ObLLVMBasicBlock init_result_block;
2912
ObLLVMBasicBlock pipe_result_block;
2913
OZ (generator_.get_helper().create_block(
2914
ObString("pipe_row_block"), generator_.get_func(), pipe_row_block));2915
OZ (generator_.get_helper().create_block(
2916
ObString("init_result_block"), generator_.get_func(), init_result_block));2917
OZ (generator_.get_helper().create_block(
2918
ObString("pipe_result_block"), generator_.get_func(), pipe_result_block));2919
OZ (generator_.get_helper().create_br(pipe_row_block));
2920
OZ (generator_.set_current(pipe_row_block));
2922
ObLLVMValue p_result;
2923
ObLLVMValue p_type_value;
2924
ObLLVMValue type_value;
2925
ObLLVMValue is_invalid;
2926
ObLLVMType obj_param_type;
2927
ObLLVMType obj_param_type_pointer;
2928
// 检查result数组是否已经初始化
2929
OZ (generator_.extract_result_from_context(
2930
generator_.get_vars().at(generator_.CTX_IDX), p_result));
2931
OZ (generator_.get_adt_service().get_objparam(obj_param_type));
2932
OZ (obj_param_type.get_pointer_to(obj_param_type_pointer));
2933
OZ (generator_.get_helper().create_bit_cast(ObString("obobj_to_obobjparam"),2934
p_result, obj_param_type_pointer, p_result));
2935
OZ (generator_.extract_type_ptr_from_objparam(p_result, p_type_value));
2936
OZ (generator_.get_helper().create_load(
2937
ObString("load_result_type"), p_type_value, type_value));2938
OZ (generator_.get_helper().create_icmp_eq(type_value, ObMaxType, is_invalid));
2939
OZ (generator_.get_helper().create_cond_br(is_invalid, init_result_block, pipe_result_block));
2942
ObSEArray<ObLLVMValue, 3> args;
2943
ObLLVMValue var_idx, init_value, var_value, extend_value;
2944
ObLLVMValue ret_err;
2945
ObLLVMValue var_type, type_id;
2946
int64_t init_size = 0;
2947
OZ (generator_.set_current(init_result_block));
2948
CK (OB_NOT_NULL(s.get_namespace()));
2949
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
2950
OZ (generator_.get_helper().get_int8(s.get_type().get_type(), var_type));
2951
OZ (args.push_back(var_type));
2952
OZ (generator_.get_helper().get_int64(s.get_type().get_user_type_id(), type_id));
2953
OZ (args.push_back(type_id));
2954
OZ (generator_.get_helper().get_int64(OB_INVALID_INDEX, var_idx));
2955
OZ (args.push_back(var_idx));
2956
OZ (s.get_namespace()->get_size(PL_TYPE_INIT_SIZE, s.get_type(), init_size));
2957
OZ (generator_.get_helper().get_int32(init_size, init_value));
2958
OZ (args.push_back(init_value));
2959
OZ (generator_.generate_null_pointer(ObIntType, init_value));
2960
OZ (args.push_back(init_value));
2961
OZ (generator_.get_helper().create_call(ObString("spi_alloc_complex_var"),2962
generator_.get_spi_service().spi_alloc_complex_var_,
2965
OZ (generator_.check_success(
2966
ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
2968
OZ (generator_.extract_result_from_context(
2969
generator_.get_vars().at(generator_.CTX_IDX), var_value));
2970
OZ (generator_.get_helper().create_bit_cast(
2971
ObString("obobj_to_obobjparam"), var_value, obj_param_type_pointer, var_value));2972
OZ (generator_.extract_extend_from_objparam(var_value, s.get_type(), extend_value));
2973
OZ (s.get_type().generate_construct(
2974
generator_, *s.get_namespace(), extend_value, &s));
2975
OZ (generator_.get_helper().create_br(pipe_result_block));
2978
ObLLVMValue p_result_obj;
2979
OZ (generator_.set_current(pipe_result_block));
2980
OZ (generator_.generate_expr(s.get_row(), s, OB_INVALID_INDEX, p_result_obj));
2982
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX))); //PL的执行环境
2983
OZ (args.push_back(p_result_obj));
2984
OZ (generator_.get_helper().create_call(ObString("spi_pipe_row_to_result"),2985
generator_.get_spi_service().spi_pipe_row_to_result_,
2987
OZ (generator_.check_success(ret_err,
2989
s.get_block()->in_notfound(),
2990
s.get_block()->in_warning()));
2995
int ObPLCodeGenerateVisitor::visit(const ObPLGotoStmt &s)
2997
int ret = OB_SUCCESS;
2998
if (NULL == generator_.get_current().get_v()) {3000
} else if (OB_FAIL(generator_.set_debug_location(s))) {3001
LOG_WARN("failed to set debug location", K(ret));3002
} else if (OB_FAIL(generator_.generate_goto_label(s))) {3003
LOG_WARN("failed to generate goto label", K(ret));3005
ObLLVMBasicBlock entry_blk;
3006
if (!s.get_dst_label().empty()) {3007
if (OB_FAIL(generator_.get_helper().create_block(ObString("goto_blk"),3008
generator_.get_func(), entry_blk))) {3009
LOG_WARN("faile to create basic block.", K(ret));3010
} else if (OB_FAIL(generator_.get_helper().create_br(entry_blk))) {3011
LOG_WARN("failed to create br instr", K(ret));3012
} else if (OB_FAIL(generator_.set_current(entry_blk))) {3013
LOG_WARN("failed to set current block", K(ret));3014
} else if (OB_FAIL(generator_.get_helper().set_insert_point(entry_blk))) {3015
LOG_WARN("failed to set insert point", K(ret));3017
#define GEN_BR_WITH_COLSE_CURSOR(goto_dst) \
3019
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_cursor_stmt_count(); ++i) { \3020
const ObPLCursorForLoopStmt *cs = \
3021
static_cast<const ObPLCursorForLoopStmt *>(s.get_cursor_stmt(i)); \
3022
if (OB_NOT_NULL(cs)) { \3023
CK (OB_NOT_NULL(cs->get_cursor())); \
3024
OZ (generator_.generate_close(static_cast<const ObPLStmt&>(*cs), \
3025
cs->get_cursor()->get_package_id(), \
3026
cs->get_cursor()->get_routine_id(), \
3029
ret = OB_ERR_UNEXPECTED;\
3030
LOG_WARN("null goto cursor for loop stmt", K(ret));\3033
if (OB_SUCC(ret)) { \3034
ObSEArray<ObLLVMValue, 1> args; \
3035
ObLLVMValue result; \
3036
if (OB_FAIL(args.push_back(generator_.get_vars().at(generator_.CTX_IDX)))) { \3037
LOG_WARN("fail to push back.", K(ret)); \3038
} else if (OB_FAIL(generator_.get_helper().create_call(ObString("check_early_exit"), generator_.get_spi_service().spi_check_early_exit_, args, result))) { \3039
LOG_WARN("fail to create call check_early_exit", K(ret)); \3040
} else if (OB_FAIL(generator_.check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) { \3041
LOG_WARN("fail to check success", K(ret)); \3042
} else if (OB_FAIL(generator_.get_helper().create_br(goto_dst))) { \3043
LOG_WARN("failed to create br instr", K(ret)); \3048
//跳转目的地和跳转语句之间的所有循环的栈都需要重置
3049
#define RESTORE_LOOP_STACK(src_level, dst_level) \
3051
for (int64_t i = generator_.get_loop_count() - 1; OB_SUCC(ret) && i >= 0; --i) { \3052
ObPLCodeGenerator::LoopStack::LoopInfo &loop_info = generator_.get_loops()[i]; \
3053
LOG_DEBUG("loop info", K(i), K(loop_info.level_), K(src_level), K(dst_level)); \3054
if (loop_info.level_ <= src_level && loop_info.level_ >= dst_level) { \3055
if (OB_FAIL(generator_.get_helper().stack_restore(loop_info.loop_))) { \3056
LOG_WARN("failed to stack_restore", K(ret), K(src_level), K(dst_level)); \3058
LOG_DEBUG("success stack restore", \3059
K(i), K(loop_info.level_), K(src_level), K(dst_level)); \
3065
hash::HashMapPair<ObPLCodeGenerator::goto_label_flag, std::pair<ObLLVMBasicBlock, ObLLVMBasicBlock>> pair;
3066
int tmp_ret = generator_.get_goto_label_map().get_refactored(
3067
s.get_dst_stmt()->get_stmt_id(), pair);
3068
if (OB_SUCCESS == tmp_ret) {3069
RESTORE_LOOP_STACK(s.get_level(), s.get_dst_stmt()->get_level());
3070
if (ObPLCodeGenerator::goto_label_flag::GOTO_LABEL_CG == pair.first) {3071
GEN_BR_WITH_COLSE_CURSOR(pair.second.second);
3073
GEN_BR_WITH_COLSE_CURSOR(pair.second.first);
3075
} else if (OB_HASH_NOT_EXIST == tmp_ret) {3076
ObLLVMBasicBlock dst_blk;
3077
ObLLVMBasicBlock stack_save_blk;
3078
if (OB_FAIL(generator_.get_helper().create_block(s.get_dst_label(),
3079
generator_.get_func(), dst_blk))) {3080
LOG_WARN("faile to create dst block", K(ret));3081
} else if (OB_FAIL(generator_.get_helper().create_block(s.get_dst_label(),
3082
generator_.get_func(), stack_save_blk))) {3083
LOG_WARN("faile to create stack save block", K(ret));3084
} else if (OB_FAIL(pair.init(ObPLCodeGenerator::goto_label_flag::GOTO_LABEL_EXIST,
3085
std::pair<ObLLVMBasicBlock, ObLLVMBasicBlock>(stack_save_blk, dst_blk)))) {3086
LOG_WARN("failed to init pair", K(ret));3087
} else if (OB_FAIL(generator_.get_goto_label_map().set_refactored(
3088
s.get_dst_stmt()->get_stmt_id(), pair))) {3089
LOG_WARN("fill hash map failed", K(ret));3091
GEN_BR_WITH_COLSE_CURSOR(stack_save_blk);
3094
ret = OB_ERR_UNEXPECTED;
3095
LOG_WARN("failed to create goto label", K(ret));3097
#undef RESTORE_LOOP_STACK
3100
ObLLVMBasicBlock new_blk;
3101
if (OB_FAIL(generator_.get_helper().create_block(ObString("after_goto"),3102
generator_.get_func(), new_blk))) {3103
LOG_WARN("failed to create basic block", K(ret));3104
} else if (OB_FAIL(generator_.set_current(new_blk))) {3105
LOG_WARN("failed to set current block", K(ret));3109
ret = OB_ERR_ZERO_LENGTH_IDENTIFIER;
3110
LOG_WARN("goto label is empty", K(ret));3116
int ObPLCodeGenerateVisitor::visit(const ObPLInterfaceStmt &s)
3118
int ret = OB_SUCCESS;
3119
ObSEArray<ObLLVMValue, 2> args;
3121
ObLLVMValue interface_name_length;
3122
ObLLVMValue ret_err;
3123
const ObString interface_name = s.get_entry();
3124
CK (!interface_name.empty());
3125
OZ (args.push_back(generator_.get_vars().at(generator_.CTX_IDX)));
3126
OZ (generator_.generate_string(interface_name, entry, interface_name_length));
3127
OZ (args.push_back(entry));
3128
OZ (generator_.get_helper().create_call(ObString("spi_interface_impl"),3129
generator_.get_spi_service().spi_interface_impl_,
3132
OZ (generator_.check_success(ret_err,
3134
s.get_block()->in_notfound(),
3135
s.get_block()->in_warning()));
3139
int ObPLCodeGenerateVisitor::visit(const ObPLDoStmt &s)
3141
int ret = OB_SUCCESS;
3142
if (NULL == generator_.get_current().get_v()) {3144
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {3145
LOG_WARN("failed to set insert point", K(ret));3146
} else if (OB_FAIL(generator_.set_debug_location(s))) {3147
LOG_WARN("failed to set debug location", K(ret));3148
} else if (OB_FAIL(generator_.generate_goto_label(s))) {3149
LOG_WARN("failed to generate goto label", K(ret));3152
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_value().count(); ++i) {3153
const ObRawExpr *value_expr = s.get_value_expr(i);
3154
int64_t result_idx = OB_INVALID_INDEX;
3155
ObLLVMValue p_result_obj;
3156
CK(OB_NOT_NULL(value_expr));
3157
OZ(generator_.generate_expr(s.get_value_index(i), s, result_idx,p_result_obj));
3164
int ObPLCodeGenerateVisitor::visit(const ObPLCaseStmt &s)
3166
int ret = OB_SUCCESS;
3167
if (NULL == generator_.get_current().get_v()) {3169
} else if (OB_FAIL(generator_.get_helper().set_insert_point(generator_.get_current()))) {3170
LOG_WARN("failed to set insert point", K(ret));3171
} else if (OB_FAIL(generator_.set_debug_location(s))) {3172
LOG_WARN("failed to set debug location", K(ret));3173
} else if (OB_FAIL(generator_.generate_goto_label(s))) {3174
LOG_WARN("failed to generate goto label", K(ret));3176
// generate case expr, if any
3177
if (s.get_case_expr() != OB_INVALID_ID) {3178
int64_t case_expr_idx = s.get_case_expr();
3179
int64_t case_var_idx = s.get_case_var();
3180
ObLLVMValue p_result_obj;
3181
if (OB_FAIL(generator_.generate_expr(case_expr_idx, s, case_var_idx, p_result_obj))) {3182
LOG_WARN("failed to generate calc_expr func", K(ret));3186
// generate when clause
3187
ObLLVMBasicBlock continue_branch;
3189
if (OB_FAIL(generator_.get_helper().create_block(
3190
ObString("continue"), generator_.get_func(), continue_branch))) {3191
LOG_WARN("faild to create continue branch for case stmt", K(ret));3193
const ObPLCaseStmt::WhenClauses &when = s.get_when_clauses();
3194
for (int64_t i = 0; OB_SUCC(ret) && i < when.count(); ++i) {3195
const ObPLCaseStmt::WhenClause ¤t_when = when.at(i);
3196
const sql::ObRawExpr *expr = s.get_expr(current_when.expr_);
3197
ObLLVMBasicBlock current_then;
3198
ObLLVMBasicBlock current_else;
3201
ObLLVMValue is_false;
3202
if (OB_ISNULL(expr)) {3203
ret = OB_ERR_UNEXPECTED;
3204
LOG_WARN("unexpected nullptr to when expr", K(i), K(current_when));3205
} else if (OB_FAIL(generator_.get_helper().create_block(
3206
ObString("then"), generator_.get_func(), current_then))) {3207
LOG_WARN("failed to create then branch for case stmt", K(ret));3208
} else if (OB_FAIL(generator_.get_helper().create_block(
3209
ObString("else"), generator_.get_func(), current_else))) {3210
LOG_WARN("failed to create else branch for case stmt", K(ret));3211
} else if (OB_FAIL(generator_.generate_expr(
3212
current_when.expr_, s, OB_INVALID_INDEX, p_cond))) {3213
LOG_WARN("failed to generate calc_expr func", K(ret));3214
} else if (OB_FAIL(generator_.extract_value_from_objparam(
3215
p_cond, expr->get_data_type(), cond))) {3216
LOG_WARN("failed to extract_value_from_objparam", K(ret));3217
} else if (OB_FAIL(generator_.get_helper().create_icmp_eq(
3218
cond, FALSE, is_false))) {3219
LOG_WARN("failed to create_icmp_eq", K(ret));3220
} else if (OB_FAIL(generator_.get_helper().create_cond_br(
3221
is_false, current_else, current_then))) {3222
LOG_WARN("failed to create_cond_br", K(ret));3223
} else if (OB_FAIL(generator_.set_current(current_then))) {3224
LOG_WARN("failed to set current to current_then branch", K(ret));3225
} else if (OB_FAIL(visit(*current_when.body_))) {3226
LOG_WARN("failed to visit then clause for case stmt", K(ret));3227
} else if (OB_FAIL(generator_.finish_current(continue_branch))) {3228
LOG_WARN("failed to finish current", K(ret));3229
} else if (OB_FAIL(generator_.set_current(current_else))) {3230
LOG_WARN("failed to set current to current_else branch", K(ret));3240
const ObPLStmtBlock *else_clause = s.get_else_clause();
3241
if (OB_ISNULL(else_clause)) {3242
ret = OB_ERR_UNEXPECTED;
3243
LOG_WARN("else in CASE stmt is NULL in CG", K(s), K(ret));3244
} else if (OB_FAIL(visit(*else_clause))) {3245
LOG_WARN("failed to visit else clause for case stmt", K(ret));3246
} else if (OB_FAIL(generator_.finish_current(continue_branch))) {3247
LOG_WARN("failed to finish current", K(ret));3248
} else if (OB_FAIL(generator_.set_current(continue_branch))) {3249
LOG_WARN("failed to set current", K(ret));3258
int ObPLCodeGenerateVisitor::find_next_procedence_condition(common::ObIArray<std::pair<ObPLConditionType, int64_t>> &conditions,
3259
common::ObIArray<int64_t> &position_map, int64_t &idx)
3261
int ret = OB_SUCCESS;
3262
idx = OB_INVALID_INDEX;
3263
ObPLConditionType type = INVALID_TYPE;
3264
int64_t level = OB_INVALID_INDEX;
3265
for (int64_t i = 0; i < conditions.count(); ++i) {3266
bool need_ignore = false;
3267
for (int64_t j = 0; j < position_map.count(); ++j) {3268
if (i == position_map.at(j)) {3275
} else if (INVALID_TYPE == type) {3276
type = conditions.at(i).first;
3277
level = conditions.at(i).second;
3280
int compare = ObPLDeclareHandlerStmt::DeclareHandler::compare_condition(conditions.at(i).first, conditions.at(i).second, type, level);
3282
//do nothing, just continue
3284
type = conditions.at(i).first;
3285
level = conditions.at(i).second;
3293
int ObPLCodeGenerator::generate_user_type(const ObUserDefinedType &type)
3295
int ret = OB_SUCCESS;
3296
ObLLVMStructType udt_ir_type;
3297
ObSEArray<ObLLVMType, 16> elem_type_array;
3298
bool is_cursor_type = false;
3299
switch (type.get_type()) {3300
case PL_RECORD_TYPE: {3301
const ObRecordType &record_type = static_cast<const ObRecordType&>(type);
3302
OZ (build_record_type(record_type, elem_type_array));
3305
#ifdef OB_BUILD_ORACLE_PL
3306
case PL_NESTED_TABLE_TYPE: {3307
const ObNestedTableType &table_type = static_cast<const ObNestedTableType&>(type);
3308
OZ (build_nested_table_type(table_type, elem_type_array));
3311
case PL_ASSOCIATIVE_ARRAY_TYPE: {3312
const ObAssocArrayType &assoc_array_type = static_cast<const ObAssocArrayType&>(type);
3313
OZ (build_assoc_array_type(assoc_array_type, elem_type_array));
3316
case PL_VARRAY_TYPE: {3317
const ObVArrayType &varray_type = static_cast<const ObVArrayType&>(type);
3318
OZ (build_varray_type(varray_type, elem_type_array));
3322
const ObUserDefinedSubType &subtype = static_cast<const ObUserDefinedSubType&>(type);
3323
ObLLVMType base_type;
3324
CK (OB_NOT_NULL(subtype.get_base_type()));
3326
} else if (!subtype.get_base_type()->is_cursor_type()) {3327
OZ (build_subtype(subtype, elem_type_array));
3329
is_cursor_type = true;
3333
case PL_OPAQUE_TYPE: {3334
const ObOpaqueType &opaque_type = static_cast<const ObOpaqueType&>(type);
3335
OZ (build_opaque_type(opaque_type, elem_type_array));
3339
case PL_CURSOR_TYPE:
3340
case PL_REF_CURSOR_TYPE: {3341
is_cursor_type = true;
3345
ret = OB_ERR_UNEXPECTED;
3346
LOG_WARN("user defined type is invalid", K(type.get_type()), K(ret));3351
if (OB_SUCC(ret) && !is_cursor_type) {3352
if (!type.is_subtype()) {3353
OZ (helper_.create_struct_type(type.get_name(), elem_type_array, udt_ir_type), type);
3354
if (OB_SUCC(ret) && OB_ISNULL(user_type_map_.get(type.get_user_type_id()))) {3355
OZ (user_type_map_.set_refactored(type.get_user_type_id(), udt_ir_type), type);
3358
CK (1 == elem_type_array.count());
3359
if (OB_SUCC(ret) && OB_ISNULL(user_type_map_.get(type.get_user_type_id()))) {3360
OZ (user_type_map_.set_refactored(type.get_user_type_id(), elem_type_array.at(0)), type);
3364
LOG_DEBUG("generator user type",3365
K(ret), K(type.get_user_type_id()), K(ast_.get_id()), K(ast_.get_name()), K(lbt()));
3369
#ifdef OB_BUILD_ORACLE_PL
3370
int ObPLCodeGenerator::build_nested_table_type(const ObNestedTableType &table_type,
3371
ObIArray<jit::ObLLVMType> &elem_type_array)
3373
int ret = OB_SUCCESS;
3374
if (OB_FAIL(build_collection_type(table_type, elem_type_array))) {3375
LOG_WARN("declare collection super type failed", K(ret));3380
int ObPLCodeGenerator::build_assoc_array_type(const ObAssocArrayType &array_type,
3381
ObIArray<jit::ObLLVMType> &elem_type_array)
3383
int ret = OB_SUCCESS;
3385
ObLLVMType obj_type;
3386
ObLLVMType key_type;
3388
ObLLVMType int_type;
3389
ObLLVMType sort_type;
3390
if (OB_FAIL(build_collection_type(array_type, elem_type_array))) {3391
LOG_WARN("declare collection super type failed", K(ret));3392
} else if (OB_FAIL(adt_service_.get_obj(obj_type))) {3393
LOG_WARN("failed to get obj type", K(ret));3394
} else if (OB_FAIL(obj_type.get_pointer_to(key_type))) {3395
LOG_WARN("failed to get_pointer_to", K(ret));3396
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int_type))) {3397
LOG_WARN("failed to get int type", K(ret));3398
} else if (OB_FAIL(int_type.get_pointer_to(sort_type))) {3399
LOG_WARN("failed to get_pointer_to", K(ret));3400
} else if (OB_FAIL(elem_type_array.push_back(key_type))) {3401
LOG_WARN("push_back error", K(ret));3402
} else if (OB_FAIL(elem_type_array.push_back(sort_type))) {3403
LOG_WARN("push_back error", K(ret));3404
} else { /*do nothing*/ }3408
int ObPLCodeGenerator::build_varray_type(const ObVArrayType &array_type,
3409
ObIArray<jit::ObLLVMType> &elem_type_array)
3411
int ret = OB_SUCCESS;
3412
ObLLVMType int_type;
3413
if (OB_FAIL(build_collection_type(array_type, elem_type_array))) {3414
LOG_WARN("declare collection super type failed", K(ret));3415
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int_type))) {3416
LOG_WARN("failed to get int type", K(ret));3417
} else if (OB_FAIL(elem_type_array.push_back(int_type))) {3418
LOG_WARN("push_back error", K(ret));3419
} else { /*do nothing*/ }3423
int ObPLCodeGenerator::build_collection_type(const ObCollectionType &collection_type,
3424
ObIArray<ObLLVMType> &elem_type_array)
3426
int ret = OB_SUCCESS;
3428
//common::ObIAllocator *allocator_;
3429
ObLLVMType allocator_type;
3430
//common::ObDataType element_type_;
3431
ObLLVMType element_type;
3433
ObLLVMType count_type;
3435
ObLLVMType first_type;
3437
ObLLVMType last_type;
3439
ObLLVMType element_ir_type;
3440
ObLLVMType data_array_type;
3441
ObLLVMType data_array_pointer_type;
3443
OZ (build_composite(elem_type_array));
3444
OZ (helper_.get_llvm_type(ObIntType, allocator_type));
3445
OZ (adt_service_.get_elem_desc(element_type));
3446
OZ (helper_.get_llvm_type(ObIntType, count_type));
3447
OZ (helper_.get_llvm_type(ObIntType, first_type));
3448
OZ (helper_.get_llvm_type(ObIntType, last_type));
3449
OZ (elem_type_array.push_back(allocator_type));
3450
OZ (elem_type_array.push_back(element_type));
3451
OZ (elem_type_array.push_back(count_type));
3452
OZ (elem_type_array.push_back(first_type));
3453
OZ (elem_type_array.push_back(last_type));
3454
OZ (get_datum_type(collection_type.get_element_type(), element_ir_type));
3455
OZ (ObLLVMHelper::get_array_type(element_ir_type, 0, data_array_type));
3456
OZ (data_array_type.get_pointer_to(data_array_pointer_type));
3457
OZ (elem_type_array.push_back(data_array_pointer_type));
3462
int ObPLCodeGenerator::build_record_type(const ObRecordType &record_type,
3463
ObIArray<jit::ObLLVMType> &elem_type_array)
3465
int ret = OB_SUCCESS;
3468
ObLLVMType count_type;
3469
ObLLVMType is_null_type;
3470
ObLLVMType null_array_type;
3471
ObLLVMType meta_type;
3472
ObLLVMType meta_array_type;
3473
ObLLVMType member_type;
3474
ObLLVMType member_array_type;
3476
OZ (build_composite(elem_type_array));
3477
OZ (helper_.get_llvm_type(ObInt32Type, count_type));
3478
OZ (elem_type_array.push_back(count_type));
3480
OZ (helper_.get_llvm_type(ObTinyIntType, is_null_type));
3481
for (int64_t i = 0; OB_SUCC(ret) && i < record_type.get_record_member_count(); ++i) {3482
OZ (elem_type_array.push_back(is_null_type));
3485
OZ (adt_service_.get_data_type(meta_type));
3486
for (int64_t i = 0; OB_SUCC(ret) && i < record_type.get_record_member_count(); ++i) {3487
OZ (elem_type_array.push_back(meta_type));
3490
for (int64_t i = 0; OB_SUCC(ret) && i < record_type.get_record_member_count(); ++i) {3491
CK (OB_NOT_NULL(record_type.get_record_member_type(i)));
3492
OZ (get_datum_type(*record_type.get_record_member_type(i), member_type));
3493
OZ (elem_type_array.push_back(member_type));
3499
int ObPLCodeGenerator::build_composite(ObIArray<jit::ObLLVMType> &elem_type_array)
3501
int ret = OB_SUCCESS;
3508
OZ (helper_.get_llvm_type(ObInt32Type, type));
3509
OZ (elem_type_array.push_back(type));
3510
OZ (helper_.get_llvm_type(ObIntType, id));
3511
OZ (elem_type_array.push_back(id));
3512
OZ (helper_.get_llvm_type(ObTinyIntType, is_null));
3513
OZ (elem_type_array.push_back(is_null));
3517
#ifdef OB_BUILD_ORACLE_PL
3518
int ObPLCodeGenerator::build_subtype(const ObUserDefinedSubType &subtype,
3519
ObIArray<jit::ObLLVMType> &elem_type_array)
3521
int ret = OB_SUCCESS;
3522
ObLLVMType base_type;
3523
CK (OB_NOT_NULL(subtype.get_base_type()));
3524
OZ (get_datum_type(*subtype.get_base_type(), base_type));
3525
OZ (elem_type_array.push_back(base_type));
3529
int ObPLCodeGenerator::build_opaque_type(const ObUserDefinedType &opaque_type,
3530
ObIArray<jit::ObLLVMType> &elem_type_array)
3532
int ret = OB_SUCCESS;
3533
UNUSED(opaque_type);
3535
OZ (helper_.get_llvm_type(ObInt32Type, type));
3536
OZ (elem_type_array.push_back(type));
3541
int ObPLCodeGenerator::init()
3543
int ret = OB_SUCCESS;
3545
// CG local types + external types at least, so pre-allocate doubled buckets
3546
// bucket number will grow up automatically if udt_count_guess is not enough
3547
int64_t udt_count_guess =
3548
(ast_.get_user_type_table().get_count() +
3549
ast_.get_user_type_table().get_external_types().count()) * 2;
3551
// make udt_count_guess at least 64, to prevent size grow up frequently in bad case
3552
if (udt_count_guess < 64) {3553
udt_count_guess = 64;
3556
int64_t goto_label_count_guess = 64;
3557
if (OB_NOT_NULL(ast_.get_body()) &&
3558
ast_.get_body()->get_stmts().count() > goto_label_count_guess) {3559
goto_label_count_guess = ast_.get_body()->get_stmts().count();
3562
if (OB_FAIL(user_type_map_.create(
3564
ObMemAttr(MTL_ID(), GET_PL_MOD_STRING(OB_PL_CODE_GEN))))){3565
LOG_WARN("failed to create user_type_map_", K(ret), K(udt_count_guess));3566
} else if (OB_FAIL(di_user_type_map_.create(
3568
ObMemAttr(MTL_ID(), GET_PL_MOD_STRING(OB_PL_CODE_GEN))))){3569
LOG_WARN("failed to create di_user_type_map_", K(ret), K(udt_count_guess));3570
} else if (OB_FAIL(goto_label_map_.create(
3571
goto_label_count_guess,
3572
ObMemAttr(MTL_ID(), GET_PL_MOD_STRING(OB_PL_CODE_GEN))))) {3573
LOG_WARN("failed to create goto_label_map_", K(ret), K(goto_label_count_guess));3574
} else if (debug_mode_ && OB_FAIL(di_helper_.init(helper_.get_jc()))) {3575
LOG_WARN("failed to init di helper", K(ret));3576
} else if (OB_FAIL(init_spi_service())) {3577
LOG_WARN("failed to init spi service", K(ret));3578
} else if (OB_FAIL(init_adt_service())) {3579
LOG_WARN("failed to init adt service", K(ret));3580
} else if (OB_FAIL(init_eh_service())) {3581
LOG_WARN("failed to init eh service", K(ret));3582
} else if (OB_FAIL(init_di_adt_service())) {3583
LOG_WARN("failed to init di service", K(ret));3585
ObSEArray<ObLLVMType, 8> arg_types;
3586
ObLLVMFunctionType ft;
3587
ObLLVMType pl_exec_context_type;
3588
ObLLVMType pl_exec_context_pointer_type;
3589
ObLLVMType int64_type;
3590
ObLLVMType int64_pointer_type;
3591
ObLLVMType int32_type;
3592
ObLLVMType bool_type;
3593
if (OB_FAIL(adt_service_.get_pl_exec_context(pl_exec_context_type))) {3594
LOG_WARN("failed to get argv type", K(ret));3595
} else if (OB_FAIL(pl_exec_context_type.get_pointer_to(pl_exec_context_pointer_type))) {3596
LOG_WARN("failed to get_pointer_to", K(ret));3597
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {3598
LOG_WARN("failed to get_llvm_type", K(ret));3599
} else if (OB_FAIL(int64_type.get_pointer_to(int64_pointer_type))) {3600
LOG_WARN("failed to get_llvm_type", K(ret));3601
} else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {3602
LOG_WARN("failed to get_llvm_type", K(ret));3603
} else if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, bool_type))) {3604
LOG_WARN("failed to get_llvm_type", K(ret));3605
} else { /*do nothing*/ }3608
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3609
LOG_WARN("push_back error", K(ret));3610
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //uint64_t package id3611
LOG_WARN("push_back error", K(ret));3612
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //uint64_t proc id3613
LOG_WARN("push_back error", K(ret));3614
} else if (OB_FAIL(arg_types.push_back(int64_pointer_type))) { //int64_t* subprogram path3615
LOG_WARN("push_back error", K(ret));3616
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t path length3617
LOG_WARN("push_back error", K(ret));3618
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t line number3619
LOG_WARN("push_back error", K(ret));3620
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t ArgC3621
LOG_WARN("push_back error", K(ret));3622
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t[] ArgV3623
LOG_WARN("push_back error", K(ret));3624
} else if (OB_FAIL(arg_types.push_back(int64_pointer_type))) { //int64_t* nocopy params3625
LOG_WARN("push_back error", K(ret));3626
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t dblink id3627
LOG_WARN("push_back error", K(ret));3628
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3629
LOG_WARN("failed to get function type", K(ret));3630
} else if (OB_FAIL(helper_.create_function(ObString("pl_execute"), ft, pl_execute_))) {3631
LOG_WARN("failed to create function", K(ret));3632
} else { /*do nothing*/ }3635
//declare user type var addr
3638
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3639
LOG_WARN("push_back error", K(ret));3640
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t var_index3641
LOG_WARN("push_back error", K(ret));3642
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //int64_t var_addr3643
LOG_WARN("push_back error", K(ret));3644
} else if (OB_FAIL(arg_types.push_back(int32_type))) { //int32_t init_value3645
LOG_WARN("push_back error", K(ret));3646
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3647
LOG_WARN("failed to get function type", K(ret));3648
} else if (OB_FAIL(helper_.create_function(ObString("set_user_type_var"), ft, set_user_type_var_))) {3649
LOG_WARN("failed to create function", K(ret));3650
} else { /*do nothing*/ }3652
// declare set_implicit_in_forall
3655
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3656
LOG_WARN("push_back error", K(ret));3657
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3658
LOG_WARN("push_back error", K(ret));3659
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3660
LOG_WARN("failed to get function type", K(ret));3661
} else if (OB_FAIL(helper_.create_function(ObString("set_implicit_cursor_in_forall"), ft, set_implicit_cursor_in_forall_))) {3662
LOG_WARN("failed to create function", K(ret));3663
} else { /*do nothing*/ }3665
// declare unset_implicit_in_forall
3668
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) {3669
LOG_WARN("push_back error", K(ret));3670
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3671
LOG_WARN("failed to get function type", K(ret));3672
} else if (OB_FAIL(helper_.create_function(ObString("unset_implicit_cursor_in_forall"), ft, unset_implicit_cursor_in_forall_))) {3673
LOG_WARN("failed to create function", K(ret));3674
} else { /*do nothing*/ }3680
int ObPLCodeGenerator::init_spi_service()
3682
int ret = OB_SUCCESS;
3683
ObSEArray<ObLLVMType, 9> arg_types;
3684
ObLLVMFunctionType ft;
3685
ObLLVMType pl_exec_context_type;
3686
ObLLVMType pl_exec_context_pointer_type;
3687
ObLLVMType obj_param_type;
3688
ObLLVMType obj_param_pointer_type;
3689
ObLLVMType obj_type;
3690
ObLLVMType obj_pointer_type;
3691
ObLLVMType data_type;
3692
ObLLVMType data_type_pointer_type;
3693
ObLLVMType int64_type;
3694
ObLLVMType int32_type;
3695
ObLLVMType bool_type;
3696
ObLLVMType char_type;
3697
ObLLVMType int_pointer_type;
3698
ObLLVMType bool_type_pointer_type;
3700
if (OB_FAIL(adt_service_.get_pl_exec_context(pl_exec_context_type))) {3701
LOG_WARN("failed to get argv type", K(ret));3702
} else if (OB_FAIL(pl_exec_context_type.get_pointer_to(pl_exec_context_pointer_type))) {3703
LOG_WARN("failed to get_pointer_to", K(ret));3704
} else if (OB_FAIL(adt_service_.get_objparam(obj_param_type))) {3705
LOG_WARN("failed to get argv type", K(ret));3706
} else if (OB_FAIL(obj_param_type.get_pointer_to(obj_param_pointer_type))) {3707
LOG_WARN("failed to get_pointer_to", K(ret));3708
} else if (OB_FAIL(adt_service_.get_obj(obj_type))) {3709
LOG_WARN("failed to get argv type", K(ret));3710
} else if (OB_FAIL(obj_type.get_pointer_to(obj_pointer_type))) {3711
LOG_WARN("failed to get pointer to", K(ret));3712
} else if (OB_FAIL(adt_service_.get_data_type(data_type))) {3713
LOG_WARN("failed to get argv type", K(ret));3714
} else if (OB_FAIL(data_type.get_pointer_to(data_type_pointer_type))) {3715
LOG_WARN("failed to get pointer to", K(ret));3716
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {3717
LOG_WARN("failed to get_llvm_type", K(ret));3718
} else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {3719
LOG_WARN("failed to get_llvm_type", K(ret));3720
} else if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, bool_type))) {3721
LOG_WARN("failed to get_llvm_type", K(ret));3722
} else if (OB_FAIL(helper_.get_llvm_type(ObCharType, char_type))) {3723
LOG_WARN("failed to get_llvm_type", K(ret));3724
} else if (OB_FAIL(int64_type.get_pointer_to(int_pointer_type))) {3725
LOG_WARN("failed to get_pointer_to", K(ret));3726
} else if (OB_FAIL(bool_type.get_pointer_to(bool_type_pointer_type))) {3727
LOG_WARN("failed to get pointer to", K(ret));3728
} else { /*do nothing*/ }3732
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3733
LOG_WARN("push_back error", K(ret));3734
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3735
LOG_WARN("push_back error", K(ret));3736
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3737
LOG_WARN("push_back error", K(ret));3738
} else if (OB_FAIL(arg_types.push_back(obj_param_pointer_type))) {3739
LOG_WARN("push_back error", K(ret));3740
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3741
LOG_WARN("failed to get function type", K(ret));3742
} else if (OB_FAIL(helper_.create_function(ObString("spi_calc_expr"), ft, spi_service_.spi_calc_expr_))) {3743
LOG_WARN("failed to create function", K(ret));3744
} else { /*do nothing*/ }3749
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3750
LOG_WARN("push_back error", K(ret));3751
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3752
LOG_WARN("push_back error", K(ret));3753
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3754
LOG_WARN("push_back error", K(ret));3755
} else if (OB_FAIL(arg_types.push_back(obj_param_pointer_type))) {3756
LOG_WARN("push_back error", K(ret));3757
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3758
LOG_WARN("failed to get function type", K(ret));3759
} else if (OB_FAIL(helper_.create_function(ObString("spi_calc_package_expr"), ft, spi_service_.spi_calc_package_expr_))) {3760
LOG_WARN("failed to create function", K(ret));3761
} else { /*do nothing*/ }3766
OZ (arg_types.push_back(pl_exec_context_pointer_type));
3767
OZ (arg_types.push_back(obj_param_pointer_type));
3768
OZ (arg_types.push_back(int64_type));
3769
OZ (arg_types.push_back(obj_param_pointer_type));
3770
OZ (arg_types.push_back(bool_type));
3771
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
3772
OZ (helper_.create_function(ObString("spi_convert_objparam"), ft, spi_service_.spi_convert_objparam_));3777
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3778
LOG_WARN("push_back error", K(ret));3779
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3780
LOG_WARN("push_back error", K(ret));3781
} else if (OB_FAIL(arg_types.push_back(obj_param_pointer_type))) {3782
LOG_WARN("push_back error", K(ret));3783
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3784
LOG_WARN("push_back error", K(ret));3785
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3786
LOG_WARN("push_back error", K(ret));3787
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3788
LOG_WARN("failed to get function type", K(ret));3789
} else if (OB_FAIL(helper_.create_function(ObString("spi_set_variable"), ft, spi_service_.spi_set_variable_))) {3790
LOG_WARN("failed to create function", K(ret));3791
} else { /*do nothing*/ }3796
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3797
LOG_WARN("push_back error", K(ret));3798
} else if (OB_FAIL(arg_types.push_back(char_type))) {3799
LOG_WARN("push_back error", K(ret));3800
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3801
LOG_WARN("push_back error", K(ret));3802
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3803
LOG_WARN("push_back error", K(ret));3804
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3805
LOG_WARN("push_back error", K(ret));3806
} else if (OB_FAIL(arg_types.push_back(data_type_pointer_type))) {3807
LOG_WARN("push_back error", K(ret));3808
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3809
LOG_WARN("push_back error", K(ret));3810
} else if (OB_FAIL(arg_types.push_back(bool_type_pointer_type))) {3811
LOG_WARN("push_back error", K(ret));3812
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3813
LOG_WARN("push_back error", K(ret));3814
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3815
LOG_WARN("push_back error", K(ret));3816
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3817
LOG_WARN("push_back error", K(ret));3818
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3819
LOG_WARN("push_back error", K(ret));3820
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3821
LOG_WARN("failed to get function type", K(ret));3822
} else if (OB_FAIL(helper_.create_function(ObString("spi_query"), ft, spi_service_.spi_query_))) {3823
LOG_WARN("failed to create function", K(ret));3824
} else { /*do nothing*/ }3829
OZ (arg_types.push_back(pl_exec_context_pointer_type));
3830
OZ (arg_types.push_back(char_type));
3831
OZ (arg_types.push_back(bool_type));
3832
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
3833
OZ (helper_.create_function(ObString("spi_end_trans"), ft, spi_service_.spi_end_trans_));3838
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3839
LOG_WARN("push_back error", K(ret));3840
} else if (OB_FAIL(arg_types.push_back(char_type))) {3841
LOG_WARN("push_back error", K(ret));3842
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3843
LOG_WARN("push_back error", K(ret));3844
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3845
LOG_WARN("push_back error", K(ret));3846
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3847
LOG_WARN("push_back error", K(ret));3848
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3849
LOG_WARN("push_back error", K(ret));3850
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3851
LOG_WARN("push_back error", K(ret));3852
} else if (OB_FAIL(arg_types.push_back(data_type_pointer_type))) {3853
LOG_WARN("push_back error", K(ret));3854
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3855
LOG_WARN("push_back error", K(ret));3856
} else if (OB_FAIL(arg_types.push_back(bool_type_pointer_type))) {3857
LOG_WARN("push_back error", K(ret));3858
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3859
LOG_WARN("push_back error", K(ret));3860
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3861
LOG_WARN("push_back error", K(ret));3862
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3863
LOG_WARN("push_back error", K(ret));3864
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3865
LOG_WARN("push_back error", K(ret));3866
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3867
LOG_WARN("push_back error", K(ret));3868
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3869
LOG_WARN("failed to get function type", K(ret));3870
} else if (OB_FAIL(helper_.create_function(ObString("spi_execute"), ft, spi_service_.spi_execute_))) {3871
LOG_WARN("failed to create function", K(ret));3872
} else { /*do nothing*/ }3877
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3878
LOG_WARN("push_back error", K(ret));3879
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3880
LOG_WARN("push_back error", K(ret));3881
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3882
LOG_WARN("push_back error", K(ret));3883
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) { // param_mode3884
LOG_WARN("push_back error", K(ret));3885
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3886
LOG_WARN("push_back error", K(ret));3887
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3888
LOG_WARN("push_back error", K(ret));3889
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3890
LOG_WARN("push_back error", K(ret));3891
} else if (OB_FAIL(arg_types.push_back(data_type_pointer_type))) {3892
LOG_WARN("push_back error", K(ret));3893
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3894
LOG_WARN("push_back error", K(ret));3895
} else if (OB_FAIL(arg_types.push_back(bool_type_pointer_type))) {3896
LOG_WARN("push_back error", K(ret));3897
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {3898
LOG_WARN("push_back error", K(ret));3899
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3900
LOG_WARN("push_back error", K(ret));3901
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3902
LOG_WARN("push_back error", K(ret));3903
} else if (OB_FAIL(arg_types.push_back(bool_type))) {3904
LOG_WARN("push_back error", K(ret));3905
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3906
LOG_WARN("failed to get function type", K(ret));3907
} else if (OB_FAIL(helper_.create_function(ObString("spi_execute_immediate"), ft, spi_service_.spi_execute_immediate_))) {3908
LOG_WARN("failed to create function", K(ret));3909
} else { /*do nothing*/ }3914
OZ (arg_types.push_back(pl_exec_context_pointer_type));
3915
OZ (arg_types.push_back(bool_type)); //int8 type
3916
OZ (arg_types.push_back(int64_type));
3917
OZ (arg_types.push_back(int64_type));
3918
OZ (arg_types.push_back(int32_type));
3919
OZ (arg_types.push_back(int_pointer_type));
3920
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
3921
OZ (helper_.create_function(ObString("spi_alloc_complex_var"), ft, spi_service_.spi_alloc_complex_var_));3926
OZ (arg_types.push_back(pl_exec_context_pointer_type));
3927
OZ (arg_types.push_back(int64_type));
3928
OZ (arg_types.push_back(obj_param_pointer_type));
3929
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
3930
OZ (helper_.create_function(ObString("spi_construct_collection"), ft, spi_service_.spi_construct_collection_));3935
OZ (arg_types.push_back(pl_exec_context_pointer_type));
3936
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
3937
OZ (helper_.create_function(ObString("spi_clear_diagnostic_area"), ft, spi_service_.spi_clear_diagnostic_area_));3942
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3943
LOG_WARN("push_back error", K(ret));3944
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3945
LOG_WARN("push_back error", K(ret));3946
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3947
LOG_WARN("push_back error", K(ret));3948
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3949
LOG_WARN("push_back error", K(ret));3950
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3951
LOG_WARN("push_back error", K(ret));3952
} else if (OB_FAIL(arg_types.push_back(int64_type))) { // package id3953
LOG_WARN("push_back error", K(ret));3954
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3955
LOG_WARN("failed to get function type", K(ret));3956
} else if (OB_FAIL(helper_.create_function(ObString("spi_extend_collection"), ft, spi_service_.spi_extend_collection_))) {3957
LOG_WARN("failed to create function", K(ret));3958
} else { /*do nothing*/ }3963
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3964
LOG_WARN("push_back error", K(ret));3965
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3966
LOG_WARN("push_back error", K(ret));3967
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3968
LOG_WARN("push_back error", K(ret));3969
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3970
LOG_WARN("push_back error", K(ret));3971
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3972
LOG_WARN("push_back error", K(ret));3973
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3974
LOG_WARN("failed to get function type", K(ret));3975
} else if (OB_FAIL(helper_.create_function(ObString("spi_delete_collection"), ft, spi_service_.spi_delete_collection_))) {3976
LOG_WARN("failed to create function", K(ret));3977
} else { /*do nothing*/ }3982
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数3983
LOG_WARN("push_back error", K(ret));3984
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3985
LOG_WARN("push_back error", K(ret));3986
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3987
LOG_WARN("push_back error", K(ret));3988
} else if (OB_FAIL(arg_types.push_back(int64_type))) {3989
LOG_WARN("push_back error", K(ret));3990
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {3991
LOG_WARN("failed to get function type", K(ret));3992
} else if (OB_FAIL(helper_.create_function(ObString("spi_trim_collection"),3993
ft, spi_service_.spi_trim_collection_))) {3994
LOG_WARN("failed to create function", K(ret));3995
} else { /*do nothing*/ }4000
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) {4001
LOG_WARN("push_back error", K(ret));4002
} else if (OB_FAIL(arg_types.push_back(int64_type))) {4003
LOG_WARN("push_back error", K(ret));4004
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4005
LOG_WARN("failed to get function type", K(ret));4006
} else if (OB_FAIL(helper_.create_function(ObString("spi_cursor_init"), ft, spi_service_.spi_cursor_init_))) {4007
LOG_WARN("failed to create function", K(ret));4008
} else { /*do nothing*/ }4013
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4014
OZ (arg_types.push_back(char_type)); //sql
4015
OZ (arg_types.push_back(char_type));//id
4016
OZ (arg_types.push_back(int64_type));//type
4017
OZ (arg_types.push_back(bool_type));//for_update
4018
OZ (arg_types.push_back(bool_type));//hidden_rowid
4019
OZ (arg_types.push_back(int_pointer_type));//sql_param_exprs
4020
OZ (arg_types.push_back(int64_type));//sql_param_count
4021
OZ (arg_types.push_back(int64_type));//package_id
4022
OZ (arg_types.push_back(int64_type));//routine_id
4023
OZ (arg_types.push_back(int64_type));//cursor_index
4024
OZ (arg_types.push_back(int_pointer_type));//formal_param_idxs
4025
OZ (arg_types.push_back(int_pointer_type));//actual_param_exprs
4026
OZ (arg_types.push_back(int64_type));//cursor_param_count
4027
OZ (arg_types.push_back(bool_type));//skip_locked
4028
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4029
OZ (helper_.create_function(ObString("spi_cursor_open"), ft, spi_service_.spi_cursor_open_));4034
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4035
OZ (arg_types.push_back(int64_type)); //sql_expr
4036
OZ (arg_types.push_back(int_pointer_type));//sql_param_exprs
4037
OZ (arg_types.push_back(int64_type));//sql_param_count
4038
OZ (arg_types.push_back(int64_type));//package_id
4039
OZ (arg_types.push_back(int64_type));//routine_id
4040
OZ (arg_types.push_back(int64_type));//cursor_index
4041
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4042
OZ (helper_.create_function(ObString("spi_dynamic_open"), ft, spi_service_.spi_dynamic_open_));4047
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4048
OZ (arg_types.push_back(int64_type));//package_id
4049
OZ (arg_types.push_back(int64_type));//routine_id
4050
OZ (arg_types.push_back(int64_type));//cursor_index
4051
OZ (arg_types.push_back(int_pointer_type));//into_exprs
4052
OZ (arg_types.push_back(int64_type));//into_count
4053
OZ (arg_types.push_back(data_type_pointer_type));//column_types
4054
OZ (arg_types.push_back(int64_type));//type_count
4055
OZ (arg_types.push_back(bool_type_pointer_type));//exprs_not_null_flag
4056
OZ (arg_types.push_back(int_pointer_type));//pl_integer_ranges
4057
OZ (arg_types.push_back(bool_type));//is_bulk
4058
OZ (arg_types.push_back(int64_type));//limit
4059
OZ (arg_types.push_back(data_type_pointer_type));//return_type
4060
OZ (arg_types.push_back(int64_type));//return_type_count
4061
OZ (arg_types.push_back(bool_type));//is_type_record
4062
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4063
OZ (helper_.create_function(ObString("spi_cursor_fetch"), ft, spi_service_.spi_cursor_fetch_));4068
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4069
OZ (arg_types.push_back(int64_type));//package_id
4070
OZ (arg_types.push_back(int64_type));//routine_id
4071
OZ (arg_types.push_back(int64_type));//cursor_index
4072
OZ (arg_types.push_back(bool_type));//ignore
4073
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4074
OZ (helper_.create_function(ObString("spi_cursor_close"), ft, spi_service_.spi_cursor_close_));4079
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数4080
LOG_WARN("push_back error", K(ret));4081
} else if (OB_FAIL(arg_types.push_back(int64_type))) {4082
LOG_WARN("push_back error", K(ret));4083
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4084
LOG_WARN("failed to get function type", K(ret));4085
} else if (OB_FAIL(helper_.create_function(ObString("spi_destruct_collection"), ft, spi_service_.spi_destruct_collection_))) {4086
LOG_WARN("failed to create function", K(ret));4087
} else { /*do nothing*/ }4092
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数4093
LOG_WARN("push_back error", K(ret));4094
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //src4095
LOG_WARN("push_back error", K(ret));4096
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //dest4097
LOG_WARN("push_back error", K(ret));4098
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //row_size4099
LOG_WARN("push_back error", K(ret));4100
} else if (OB_FAIL(arg_types.push_back(int64_type))) { // package id4101
LOG_WARN("push_back error", K(ret));4102
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4103
LOG_WARN("failed to get function type", K(ret));4104
} else if (OB_FAIL(helper_.create_function(ObString("spi_init_collection"), ft, spi_service_.spi_init_collection_))) {4105
LOG_WARN("failed to create function", K(ret));4106
} else { /*do nothing*/ }4111
if (OB_FAIL(arg_types.push_back(int64_type))) { //src4112
LOG_WARN("push_back error", K(ret));4113
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4114
LOG_WARN("failed to get function type", K(ret));4115
} else if (OB_FAIL(helper_.create_function(ObString("spi_reset_collection"), ft, spi_service_.spi_reset_collection_))) {4116
LOG_WARN("failed to create function", K(ret));4117
} else { /*do nothing*/ }4122
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { // 函数第一个参数必须是基础环境信息隐藏参数4123
LOG_WARN("push_back error", K(ret));4124
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //src index4125
LOG_WARN("push_back error", K(ret));4126
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //dest index4127
LOG_WARN("push_back error", K(ret));4128
} else if (OB_FAIL(arg_types.push_back(int32_type))) { //subarray lower pos4129
LOG_WARN("push_back error", K(ret));4130
} else if (OB_FAIL(arg_types.push_back(int32_type))) { //subarray upper pos4131
LOG_WARN("push_back error", K(ret));4132
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4133
LOG_WARN("failed to get function type", K(ret));4134
} else if (OB_FAIL(helper_.create_function(ObString("spi_sub_nestedtable"), ft, spi_service_.spi_sub_nestedtable_))) {4135
LOG_WARN("failed to create function", K(ret));4136
} else { /*do nothing*/ }4141
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4142
OZ (arg_types.push_back(int64_type)); //allocator
4143
OZ (arg_types.push_back(obj_pointer_type)); //src
4144
OZ (arg_types.push_back(obj_pointer_type)); //dest
4145
OZ (arg_types.push_back(data_type_pointer_type)); //dest type
4146
OZ (arg_types.push_back(int64_type)); // package id
4147
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4148
OZ (helper_.create_function(ObString("spi_copy_datum"), ft, spi_service_.spi_copy_datum_));4152
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4153
OZ (arg_types.push_back(obj_pointer_type)); //src
4154
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4155
OZ (helper_.create_function(ObString("spi_destruct_obj"), ft, spi_service_.spi_destruct_obj_));4160
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数4161
LOG_WARN("push_back error", K(ret));4162
} else if (OB_FAIL(arg_types.push_back(int64_type))) { // error code4163
LOG_WARN("push_back error", K(ret));4164
} else if (OB_FAIL(arg_types.push_back(bool_type))) {4165
LOG_WARN("push_back error", K(ret));4166
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4167
LOG_WARN("failed to get function type", K(ret));4168
} else if (OB_FAIL(helper_.create_function(ObString("spi_set_pl_exception_code"), ft, spi_service_.spi_set_pl_exception_code_))) {4169
LOG_WARN("failed to create function", K(ret));4170
} else { /*do nothing*/ }4175
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) {4176
LOG_WARN("push_back error", K(ret));4177
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {4178
LOG_WARN("push_back error", K(ret));4179
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4180
LOG_WARN("failed to get function type", K(ret));4181
} else if (OB_FAIL(helper_.create_function(ObString("spi_get_pl_exception_code"), ft, spi_service_.spi_get_pl_exception_code_))) {4182
LOG_WARN("failed to create function", K(ret));4183
} else { /*do nothing*/ }4188
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4189
OZ (arg_types.push_back(int64_type));
4190
OZ (arg_types.push_back(int64_type));
4191
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4192
OZ (helper_.create_function(ObString("spi_raise_application_error"), ft, spi_service_.spi_raise_application_error_));4197
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4198
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4199
OZ (helper_.create_function(ObString("spi_check_early_exit"), ft, spi_service_.spi_check_early_exit_));4204
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4205
OZ (arg_types.push_back(obj_param_pointer_type));
4206
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4207
OZ (helper_.create_function(
4208
ObString("spi_pipe_row_to_result"), ft, spi_service_.spi_pipe_row_to_result_));4212
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4213
OZ (arg_types.push_back(int64_type));
4214
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4215
OZ (helper_.create_function(ObString("spi_check_exception_handler_legal"),4216
ft, spi_service_.spi_check_exception_handler_legal_));
4221
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4222
OZ (arg_types.push_back(char_type));
4223
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4224
OZ (helper_.create_function(ObString("spi_interface_impl"),4225
ft, spi_service_.spi_interface_impl_));
4230
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4231
OZ (arg_types.push_back(int64_type));
4232
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4233
OZ (helper_.create_function(ObString("spi_process_nocopy_params"),4234
ft, spi_service_.spi_process_nocopy_params_));
4238
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4239
OZ (arg_types.push_back(int64_type)); //allocator
4240
OZ (arg_types.push_back(obj_pointer_type)); //src
4241
OZ (arg_types.push_back(obj_pointer_type)); //dest
4242
OZ (arg_types.push_back(data_type_pointer_type)); //dest type
4243
OZ (arg_types.push_back(int64_type)); // package id
4244
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4245
OZ (helper_.create_function(ObString("spi_copy_ref_cursor"), ft, spi_service_.spi_copy_ref_cursor_));4249
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4250
OZ (arg_types.push_back(obj_pointer_type)); // ref cursor
4251
OZ (arg_types.push_back(int64_type));
4252
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4253
OZ (helper_.create_function(ObString("spi_add_ref_cursor_refcount"), ft, spi_service_.spi_add_ref_cursor_refcount_));4257
OZ (arg_types.push_back(pl_exec_context_pointer_type)); //函数第一个参数必须是基础环境信息隐藏参数
4258
OZ (arg_types.push_back(int64_type)); //package id
4259
OZ (arg_types.push_back(int64_type)); //routine id
4260
OZ (arg_types.push_back(int64_type)); //cursor index
4261
OZ (arg_types.push_back(int64_type)); //addend
4262
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4263
OZ (helper_.create_function(ObString("spi_handle_ref_cursor_refcount"), ft, spi_service_.spi_handle_ref_cursor_refcount_));4267
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4268
OZ (arg_types.push_back(int64_type));
4269
OZ (arg_types.push_back(int64_type));
4270
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4271
OZ (helper_.create_function(ObString("spi_update_package_change_info"),4272
ft, spi_service_.spi_update_package_change_info_));
4276
OZ (arg_types.push_back(obj_param_pointer_type));
4277
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4278
OZ (helper_.create_function(ObString("spi_check_composite_not_null"),4279
ft, spi_service_.spi_check_composite_not_null_));
4284
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4285
OZ (arg_types.push_back(int64_type));
4286
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4287
OZ (helper_.create_function(
4288
ObString("spi_update_location"), ft, spi_service_.spi_update_location_));4292
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4293
OZ (arg_types.push_back(int64_type));
4294
OZ (arg_types.push_back(int64_type));
4295
OZ (arg_types.push_back(char_type));
4296
OZ (arg_types.push_back(int_pointer_type));
4297
OZ (arg_types.push_back(char_type));
4298
OZ (arg_types.push_back(bool_type));
4299
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4300
OZ (helper_.create_function(ObString("spi_process_resignal"), ft, spi_service_.spi_process_resignal_error_));4304
OZ (arg_types.push_back(pl_exec_context_pointer_type));
4305
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
4306
OZ (helper_.create_function(ObString("spi_check_autonomous_trans"), ft, spi_service_.spi_check_autonomous_trans_));4312
int ObPLCodeGenerator::init_adt_service()
4314
int ret = OB_SUCCESS;
4315
if (OB_FAIL(adt_service_.init(get_param_size(), ast_.get_symbol_table().get_count()))) {4316
LOG_WARN("failed to init adt service", K(ret));4321
int ObPLCodeGenerator::init_eh_service()
4323
int ret = OB_SUCCESS;
4325
eh_service_.pl_exception_class_ = ObPLEHService::get_exception_class();
4326
eh_service_.pl_exception_base_offset_ = ObPLEHService::get_exception_base_offset();
4328
ObSEArray<ObLLVMType, 8> arg_types;
4329
ObLLVMFunctionType ft;
4330
ObLLVMType unwind_exception_type;
4331
ObLLVMType unwind_exception_pointer_type;
4332
ObLLVMType condition_type;
4333
ObLLVMType condition_pointer_type;
4334
ObLLVMType obj_type;
4335
ObLLVMType obj_pointer_type;
4336
ObLLVMType objparam_type;
4337
ObLLVMType objparam_pointer_type;
4338
ObLLVMType int_pointer_type;
4339
ObLLVMType int32_pointer_type;
4340
ObLLVMType tinyint_pointer_type;
4341
ObLLVMType char_pointer_type;
4342
ObLLVMType int64_type;
4343
ObLLVMType int32_type;
4344
ObLLVMType int8_type;
4345
ObLLVMType char_type;
4346
ObLLVMType void_type;
4348
if (OB_FAIL(adt_service_.get_unwind_exception(unwind_exception_type))) {4349
LOG_WARN("failed to get argv type", K(ret));4350
} else if (OB_FAIL(unwind_exception_type.get_pointer_to(unwind_exception_pointer_type))) {4351
LOG_WARN("failed to get pointer to", K(ret));4352
} else if (OB_FAIL(adt_service_.get_pl_condition_value(condition_type))) {4353
LOG_WARN("failed to get argv type", K(ret));4354
} else if (OB_FAIL(condition_type.get_pointer_to(condition_pointer_type))) {4355
LOG_WARN("failed to get pointer to", K(ret));4356
} else if (OB_FAIL(adt_service_.get_obj(obj_type))) {4357
LOG_WARN("failed to get argv type", K(ret));4358
} else if (OB_FAIL(obj_type.get_pointer_to(obj_pointer_type))) {4359
LOG_WARN("failed to get pointer to", K(ret));4360
} else if (OB_FAIL(adt_service_.get_objparam(objparam_type))) {4361
LOG_WARN("failed to get argv type", K(ret));4362
} else if (OB_FAIL(objparam_type.get_pointer_to(objparam_pointer_type))) {4363
LOG_WARN("failed to get pointer to", K(ret));4364
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {4365
LOG_WARN("failed to get_llvm_type", K(ret));4366
} else if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, int32_type))) {4367
LOG_WARN("failed to get_llvm_type", K(ret));4368
} else if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, int8_type))) {4369
LOG_WARN("failed to get_llvm_type", K(ret));4370
} else if (OB_FAIL(helper_.get_llvm_type(ObCharType, char_type))) {4371
LOG_WARN("failed to get_llvm_type", K(ret));4372
} else if (OB_FAIL(helper_.get_void_type(void_type))) {4373
LOG_WARN("failed to get_llvm_type", K(ret));4374
} else if (OB_FAIL(int64_type.get_pointer_to(int_pointer_type))) {4375
LOG_WARN("failed to get pointer to", K(ret));4376
} else if (OB_FAIL(int32_type.get_pointer_to(int32_pointer_type))) {4377
LOG_WARN("failed to get pointer to", K(ret));4378
} else if (OB_FAIL(int8_type.get_pointer_to(tinyint_pointer_type))) {4379
LOG_WARN("failed to get pointer to", K(ret));4380
} else if (OB_FAIL(char_type.get_pointer_to(char_pointer_type))) {4381
LOG_WARN("failed to get pointer to", K(ret));4382
} else { /*do nothing*/ }4385
if (OB_FAIL(arg_types.push_back(int64_type))) { // obplexeccontext4386
LOG_WARN("push_back error", K(ret));4387
} else if (OB_FAIL(arg_types.push_back(int64_type))) { // obplfunction4388
LOG_WARN("push_back error", K(ret));4389
} else if (OB_FAIL(arg_types.push_back(int64_type))) { // line number4390
LOG_WARN("push_back error", K(ret));4391
} else if (OB_FAIL(arg_types.push_back(int64_type))) {4392
LOG_WARN("push_back error", K(ret));4393
} else if (OB_FAIL(arg_types.push_back(condition_pointer_type))) {4394
LOG_WARN("push_back error", K(ret));4395
} else if (OB_FAIL(ObLLVMFunctionType::get(unwind_exception_pointer_type, arg_types, ft))) {4396
LOG_WARN("failed to get function type", K(ret));4397
} else if (OB_FAIL(helper_.create_function(ObString("eh_create_exception"), ft, eh_service_.eh_create_exception_))) {4398
LOG_WARN("failed to create function", K(ret));4399
} else { /*do nothing*/ }4404
if (OB_FAIL(arg_types.push_back(unwind_exception_pointer_type))) {4405
LOG_WARN("push_back error", K(ret));4406
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4407
LOG_WARN("failed to get function type", K(ret));4408
} else if (OB_FAIL(helper_.create_function(ObString("_Unwind_RaiseException"), ft, eh_service_.eh_raise_exception_))) {4409
LOG_WARN("failed to create function", K(ret));4410
} else { /*do nothing*/ }4415
if (OB_FAIL(arg_types.push_back(unwind_exception_pointer_type))) {4416
LOG_WARN("push_back error", K(ret));4417
} else if (OB_FAIL(ObLLVMFunctionType::get(void_type, arg_types, ft))) {4418
LOG_WARN("failed to get function type", K(ret));4419
} else if (OB_FAIL(helper_.create_function(ObString("_Unwind_Resume"), ft, eh_service_.eh_resume_))) {4420
LOG_WARN("failed to create function", K(ret));4421
} else { /*do nothing*/ }4426
if (OB_FAIL(arg_types.push_back(int32_type))) {4427
LOG_WARN("push_back error", K(ret));4428
} else if (OB_FAIL(arg_types.push_back(int32_type))) {4429
LOG_WARN("push_back error", K(ret));4430
} else if (OB_FAIL(arg_types.push_back(int64_type))) {4431
LOG_WARN("push_back error", K(ret));4432
} else if (OB_FAIL(arg_types.push_back(int8_type))) {4433
LOG_WARN("push_back error", K(ret));4434
} else if (OB_FAIL(arg_types.push_back(int8_type))) {4435
LOG_WARN("push_back error", K(ret));4436
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4437
LOG_WARN("failed to get function type", K(ret));4438
} else if (OB_FAIL(helper_.create_function(ObString("eh_personality"), ft, eh_service_.eh_personality_))) {4439
LOG_WARN("failed to create function", K(ret));4440
} else { /*do nothing*/ }4445
if (OB_FAIL(arg_types.push_back(int8_type))) {4446
LOG_WARN("push_back error", K(ret));4447
} else if (OB_FAIL(arg_types.push_back(int32_type))) {4448
LOG_WARN("push_back error", K(ret));4449
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {4450
LOG_WARN("push_back error", K(ret));4451
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {4452
LOG_WARN("push_back error", K(ret));4453
} else if (OB_FAIL(arg_types.push_back(char_pointer_type))) {4454
LOG_WARN("push_back error", K(ret));4455
} else if (OB_FAIL(arg_types.push_back(int_pointer_type))) {4456
LOG_WARN("push_back error", K(ret));4457
} else if (OB_FAIL(ObLLVMFunctionType::get(int32_type, arg_types, ft))) {4458
LOG_WARN("failed to get function type", K(ret));4459
} else if (OB_FAIL(helper_.create_function(ObString("eh_convert_exception"), ft, eh_service_.eh_convert_exception_))) {4460
LOG_WARN("failed to create function", K(ret));4461
} else { /*do nothing*/ }4466
if (OB_FAIL(arg_types.push_back(char_type))) {4467
LOG_WARN("push_back error", K(ret));4468
} else if (OB_FAIL(ObLLVMFunctionType::get(int64_type, arg_types, ft))) {4469
LOG_WARN("failed to get function type", K(ret));4470
} else if (OB_FAIL(helper_.create_function(ObString("eh_classify_exception"), ft, eh_service_.eh_classify_exception))) {4471
LOG_WARN("failed to create function", K(ret));4472
} else { /*do nothing*/ }4478
OZ (arg_types.push_back(char_type));
4479
OZ (arg_types.push_back(int64_type));
4480
OZ (arg_types.push_back(int64_type));
4481
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4482
OZ (helper_.create_function(ObString("eh_debug_int64"), ft, eh_service_.eh_debug_int64_));4487
OZ (arg_types.push_back(char_type));
4488
OZ (arg_types.push_back(int64_type));
4489
OZ (arg_types.push_back(int_pointer_type));
4490
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4491
OZ (helper_.create_function(ObString("eh_debug_int64ptr"), ft, eh_service_.eh_debug_int64ptr_));4496
OZ (arg_types.push_back(char_type));
4497
OZ (arg_types.push_back(int64_type));
4498
OZ (arg_types.push_back(int32_type));
4499
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4500
OZ (helper_.create_function(ObString("eh_debug_int32"), ft, eh_service_.eh_debug_int32_));4505
OZ (arg_types.push_back(char_type));
4506
OZ (arg_types.push_back(int64_type));
4507
OZ (arg_types.push_back(int32_pointer_type));
4508
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4509
OZ (helper_.create_function(ObString("eh_debug_int32ptr"), ft, eh_service_.eh_debug_int32ptr_));4514
OZ (arg_types.push_back(char_type));
4515
OZ (arg_types.push_back(int64_type));
4516
OZ (arg_types.push_back(int8_type));
4517
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4518
OZ (helper_.create_function(ObString("eh_debug_int8"), ft, eh_service_.eh_debug_int8_));4523
OZ (arg_types.push_back(char_type));
4524
OZ (arg_types.push_back(int64_type));
4525
OZ (arg_types.push_back(tinyint_pointer_type));
4526
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4527
OZ (helper_.create_function(ObString("eh_debug_int8ptr"), ft, eh_service_.eh_debug_int8ptr_));4532
OZ (arg_types.push_back(char_type));
4533
OZ (arg_types.push_back(int64_type));
4534
OZ (arg_types.push_back(obj_pointer_type));
4535
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4536
OZ (helper_.create_function(ObString("eh_debug_obj"), ft, eh_service_.eh_debug_obj_));4541
OZ (arg_types.push_back(char_type));
4542
OZ (arg_types.push_back(int64_type));
4543
OZ (arg_types.push_back(objparam_pointer_type));
4544
OZ (ObLLVMFunctionType::get(void_type, arg_types, ft));
4545
OZ (helper_.create_function(ObString("eh_debug_objparam"), ft, eh_service_.eh_debug_objparam_));4551
int ObPLCodeGenerator::set_var_addr_to_param_store(
4552
int64_t var_index, jit::ObLLVMValue &var, jit::ObLLVMValue &init_value)
4554
int ret = OB_SUCCESS;
4555
ObLLVMValue ir_index;
4556
ObLLVMType int_type;
4557
ObLLVMValue var_addr;
4559
if (OB_FAIL(helper_.get_int64(var_index, ir_index))) {4560
LOG_WARN("failed to get int64", K(ret));4561
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int_type))) {4562
LOG_WARN("failed to get_llvm_type", K(ret));4563
} else if (OB_FAIL(helper_.create_ptr_to_int(ObString("cast_ptr_to_int64"), var, int_type, var_addr))) {4564
LOG_WARN("failed to create ptr to int", K(ret));4566
} else if (OB_FAIL(generate_debug(ObString("debug"), var_addr))) {4567
LOG_WARN("failed to create call", K(ret));4570
ObSEArray<ObLLVMValue, 4> args;
4571
if (OB_FAIL(args.push_back(vars_.at(CTX_IDX)))) {4572
LOG_WARN("push_back error", K(ret));4573
} else if (OB_FAIL(args.push_back(ir_index))) {4574
LOG_WARN("push_back error", K(ret));4575
} else if (OB_FAIL(args.push_back(var_addr))) {4576
LOG_WARN("push_back error", K(ret));4577
} else if (OB_FAIL(args.push_back(init_value))) {4578
LOG_WARN("push_back error", K(ret));4579
} else if (OB_FAIL(helper_.create_call(ObString("set_var_addr"), get_user_type_var_func(), args))) {4580
LOG_WARN("failed to create call", K(ret));4581
} else { /*do nothing*/ }4586
int ObPLCodeGenerator::generate_get_collection_attr(ObLLVMValue ¶m_array,
4587
const ObObjAccessIdx ¤t_access,
4590
bool is_assoc_array,
4591
ObLLVMValue ¤t_value,
4592
ObLLVMValue &ret_value_ptr,
4593
ObLLVMBasicBlock& exit)
4595
int ret = OB_SUCCESS;
4596
ObLLVMValue ret_value;
4597
// 对于数组类型的访问, 需要确保其已经通过构造函数进行了初始化
4598
ObLLVMValue is_inited, not_init_value, not_init;
4599
ObLLVMBasicBlock after_init_block, not_init_block;
4600
OZ (helper_.create_block(ObString("after_init_block"), func_, after_init_block));4601
OZ (helper_.create_block(ObString("not_init_block"), func_, not_init_block));4602
OZ (generate_debug("generate_get_collection_attr", current_value));4603
OZ (extract_count_from_collection(current_value, is_inited));
4604
OZ (helper_.get_int64(-1, not_init_value));
4605
OZ (helper_.create_icmp(is_inited, not_init_value, ObLLVMHelper::ICMP_EQ, not_init));
4606
OZ (helper_.create_cond_br(not_init, not_init_block, after_init_block));
4607
OZ (helper_.set_insert_point(not_init_block));
4608
OZ (helper_.get_int32(OB_ERR_COLLECION_NULL, ret_value));
4609
OZ (helper_.create_store(ret_value, ret_value_ptr));
4610
OZ (helper_.create_br(exit));
4611
OZ (helper_.set_insert_point(after_init_block));
4613
ObLLVMValue data_value;
4614
if (!current_access.is_property()) {4615
// 取出集合中元素的值ObCollection->data_
4616
// 当时获取Collection的固有属性时, 不需要这么做, 固有属性都存储在Collection本身上
4617
OZ (extract_data_from_collection(current_value, data_value));
4619
// 获取下标或者固有属性在Collection中的位置信息
4621
ObLLVMValue element_idx;
4623
if (current_access.is_property()) {4625
} else if (current_access.is_const()) {4626
OZ (helper_.get_int64(current_access.var_index_ - 1, element_idx));
4628
// 非常量，那么首先用obj access中的var_index获取到变量的值，然后再获取element
4629
ObLLVMValue element_idx_ptr;
4630
OZ (helper_.create_gep(ObString("param_value"),4632
current_access.var_index_,
4634
OZ (helper_.create_load(ObString("element_idx"), element_idx_ptr, element_idx));4635
OZ (helper_.create_dec(element_idx, element_idx));
4638
// 如果不是固有属性, 需要check下标的合法性, 避免访问越界
4639
if (!current_access.is_property()) {4640
ObLLVMValue low, high_ptr, high, is_true;
4641
ObLLVMBasicBlock check_block, after_block, error_block;
4642
ObLLVMBasicBlock delete_block, after_delete_block;
4643
char check_block_name[OB_MAX_OBJECT_NAME_LENGTH];
4644
char check_after_name[OB_MAX_OBJECT_NAME_LENGTH];
4645
char check_error_name[OB_MAX_OBJECT_NAME_LENGTH];
4646
char delete_block_name[OB_MAX_OBJECT_NAME_LENGTH];
4647
char after_delete_name[OB_MAX_OBJECT_NAME_LENGTH];
4648
int64_t check_pos = 0, after_pos = 0, error_pos = 0;
4649
int64_t delete_pos = 0, after_delete_pos = 0;
4650
OZ (databuff_printf(check_block_name,
4651
OB_MAX_OBJECT_NAME_LENGTH,
4655
OZ (databuff_printf(check_after_name,
4656
OB_MAX_OBJECT_NAME_LENGTH,
4660
OZ (databuff_printf(check_error_name,
4661
OB_MAX_OBJECT_NAME_LENGTH,
4665
OZ (databuff_printf(delete_block_name,
4666
OB_MAX_OBJECT_NAME_LENGTH,
4670
OZ (databuff_printf(after_delete_name,
4671
OB_MAX_OBJECT_NAME_LENGTH,
4673
"after_delete_pos_%ld",
4675
OZ (helper_.create_block(ObString(check_pos, check_block_name), func_, check_block));
4676
OZ (helper_.create_block(ObString(after_pos, check_after_name), func_, after_block));
4677
OZ (helper_.create_block(ObString(error_pos, check_error_name), func_, error_block));
4679
OZ (helper_.get_int64(0, low));
4680
OZ (helper_.create_icmp(element_idx, low, ObLLVMHelper::ICMP_SGE, is_true));
4681
OZ (helper_.create_cond_br(is_true, check_block, error_block));
4682
OZ (helper_.set_insert_point(check_block));
4683
OZ (helper_.create_gep(ObString("rowcount"),4685
IDX_COLLECTION_COUNT,
4687
OZ (helper_.create_load(ObString("load_rowcount"), high_ptr, high));4688
OZ (helper_.create_icmp(high, element_idx, ObLLVMHelper::ICMP_SGT, is_true));
4689
OZ (helper_.create_cond_br(is_true, after_block, error_block));
4690
OZ (helper_.set_insert_point(error_block));
4691
OZ (helper_.get_int32(is_assoc_array ? OB_READ_NOTHING : OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT, ret_value));
4692
OZ (helper_.create_store(ret_value, ret_value_ptr));
4693
OZ (helper_.create_br(exit));
4694
OZ (helper_.set_insert_point(after_block));
4695
OZ (helper_.get_int32(OB_SUCCESS, ret_value));
4696
OZ (helper_.create_store(ret_value, ret_value_ptr));
4697
OZ (helper_.create_gep(ObString("table_element_array"),4703
// check deleted value
4704
ObLLVMValue p_type_value;
4705
ObLLVMValue type_value;
4706
ObLLVMValue is_deleted;
4707
OZ (helper_.create_block(ObString(delete_pos, delete_block_name), func_, delete_block));
4708
OZ (helper_.create_block(ObString(after_delete_pos, after_delete_name), func_, after_delete_block));
4709
OZ (extract_type_ptr_from_obj(current_value, p_type_value));
4710
OZ (helper_.create_load(ObString("load_type"), p_type_value, type_value));4711
OZ (helper_.create_icmp_eq(type_value, ObMaxType, is_deleted));
4712
OZ (helper_.create_cond_br(is_deleted, delete_block, after_delete_block));
4713
OZ (helper_.set_insert_point(delete_block));
4715
OZ (helper_.get_int32(OB_READ_NOTHING, ret_value));
4716
OZ (helper_.create_store(ret_value, ret_value_ptr));
4717
OZ (helper_.create_br(exit));
4719
if (current_access.var_type_.is_composite_type()) {4720
OZ (helper_.get_int8(ObExtendType, type_value));
4721
OZ (helper_.create_store(type_value, p_type_value));
4723
OZ (helper_.create_br(after_delete_block));
4725
OZ (helper_.set_insert_point(after_delete_block));
4735
int ObPLCodeGenerator::generate_get_record_attr(const ObObjAccessIdx ¤t_access,
4738
ObLLVMValue ¤t_value,
4739
ObLLVMValue &ret_value_ptr,
4740
ObLLVMBasicBlock& exit)
4742
int ret = OB_SUCCESS;
4743
ObLLVMValue ret_value;
4744
ObLLVMValue data_value;
4745
const ObUserDefinedType *user_type = NULL;
4746
const ObRecordType *record_type = NULL;
4747
int64_t field_cnt = OB_INVALID_COUNT;
4748
int64_t element_idx = RECORD_META_OFFSET; //type_ is 0 and count_ is 1
4749
if (NULL == (user_type = ast_.get_user_type_table().get_type(udt_id))
4750
&& NULL == (user_type = ast_.get_user_type_table().get_external_type(udt_id))) {4751
ret = OB_ERR_UNEXPECTED;
4752
LOG_WARN("get user type failed", K(ret));4754
CK (OB_NOT_NULL(user_type));
4755
CK (user_type->is_record_type());
4756
OX (record_type = static_cast<const ObRecordType*>(user_type));
4757
OX (element_idx += record_type->get_record_member_count()); //null map
4758
OX (element_idx += record_type->get_record_member_count()); //record meta list
4759
OV (current_access.is_const(), OB_ERR_UNEXPECTED, K(current_access));
4760
OX (element_idx += current_access.var_index_); //访问的域对应的下标
4761
if (OB_SUCC(ret) && user_type->is_object_type() && for_write) {4762
ObLLVMBasicBlock null_block, not_null_block;
4763
ObLLVMValue is_null, err_value, is_null_object;
4765
OZ (extract_isnull_from_record(current_value, is_null_object));
4767
OZ (generate_debug(ObString("object instance is null"), is_null_object));4769
OZ (get_helper().create_block(ObString("null_block"), get_func(), null_block));4770
OZ (get_helper().create_block(ObString("not_null_block"), get_func(), not_null_block));4771
OZ (get_helper().create_icmp_eq(is_null_object, TRUE, is_null));
4772
OZ (get_helper().create_cond_br(is_null, null_block, not_null_block));
4773
OZ (set_current(null_block));
4774
OZ (get_helper().get_int32(OB_ERR_ACCESS_INTO_NULL, err_value));
4775
OZ (helper_.create_store(err_value, ret_value_ptr));
4776
OZ (helper_.create_br(exit));
4777
OZ (set_current(not_null_block));
4779
OZ (helper_.create_gep(ObString("extract record data"),4786
int ObPLCodeGenerator::generate_get_attr(ObLLVMValue ¶m_array,
4787
const ObIArray<ObObjAccessIdx> &obj_access,
4789
ObLLVMValue &value_ptr, // 读取的值
4790
ObLLVMValue &ret_value_ptr, // 标识是否越界
4791
ObLLVMBasicBlock& exit) // 越界后需要跳转的BLOCK
4793
int ret = OB_SUCCESS;
4794
ObLLVMType user_type;
4795
ObLLVMValue composite_addr;
4796
ObLLVMValue ret_value;
4798
ObLLVMType int64_type;
4800
CK (!obj_access.empty());
4801
CK (obj_access.at(0).var_type_.is_composite_type()
4802
|| obj_access.at(0).var_type_.is_cursor_type());
4805
OZ (helper_.get_llvm_type(ObIntType, int64_type));
4807
OZ (helper_.get_int32(OB_SUCCESS, ret_value));
4808
OZ (helper_.create_store(ret_value, ret_value_ptr));
4809
OZ (helper_.create_gep(ObString("param_value"),4811
obj_access.at(0).var_index_,
4813
OZ (helper_.create_load(ObString("element_idx"), composite_addr, composite_addr));4815
for (int64_t i = 1; OB_SUCC(ret) && i < obj_access.count(); ++i) {4816
const ObPLDataType &parent_type = obj_access.at(i - 1).var_type_;
4817
OZ (user_type_map_.get_refactored(parent_type.get_user_type_id(), user_type),
4818
parent_type.get_user_type_id());
4819
OZ (user_type.get_pointer_to(user_type));
4820
OZ (helper_.create_int_to_ptr(ObString("var_value"), composite_addr, user_type, value));4821
CK (!obj_access.at(i).is_invalid());
4823
if (parent_type.is_collection_type()) { //数组类型4824
OZ (generate_get_collection_attr(param_array,
4828
parent_type.is_associative_array_type(),
4832
} else if (parent_type.is_record_type()) { //record类型4833
OZ (generate_get_record_attr(obj_access.at(i),
4834
parent_type.get_user_type_id(),
4838
exit), K(obj_access), K(i));
4840
ret = OB_ERR_UNEXPECTED;
4841
LOG_WARN("unexpected user type" , K(obj_access.at(i - 1).var_type_), K(ret));4845
if (obj_access.at(i).var_type_.is_composite_type()) {4846
OZ (extract_value_from_obj(value, ObExtendType, composite_addr));
4850
if (ObObjAccessIdx::get_final_type(obj_access).is_obj_type()) {4851
OZ (helper_.create_ptr_to_int(ObString("element_value_addr"), value, int64_type, value));4853
value = composite_addr;
4855
OZ (helper_.create_store(value, value_ptr));
4859
int ObPLCodeGenerator::generate_declare_cursor(const ObPLStmt &s, const int64_t &cursor_index)
4861
int ret = OB_SUCCESS;
4862
if (NULL == get_current().get_v()) {4865
const ObPLCursor *cursor = s.get_cursor(cursor_index);
4866
CK (OB_NOT_NULL(cursor));
4867
CK (ObPLCursor::INVALID != cursor->get_state());
4868
if (OB_SUCC(ret) && ObPLCursor::DUP_DECL != cursor->get_state()) { //如果是无效的cursor跳过即可4869
ObLLVMValue cursor_index_value;
4870
ObLLVMValue cursor_value;
4871
ObLLVMValue ret_err;
4872
ObSEArray<ObLLVMValue, 2> args;
4873
OZ (get_helper().set_insert_point(get_current()));
4874
OZ (set_debug_location(s));
4875
OZ (get_helper().get_int64(cursor->get_index(), cursor_index_value));
4876
OZ (args.push_back(get_vars().at(CTX_IDX)));
4877
OZ (args.push_back(cursor_index_value));
4878
OZ (get_helper().create_call(ObString("spi_cursor_init"), get_spi_service().spi_cursor_init_, args, ret_err));4879
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
4880
OZ (extract_objparam_from_context(get_vars().at(CTX_IDX), cursor->get_index(), cursor_value));
4881
OZ (helper_.create_gep(ObString("obj"), cursor_value, 0, cursor_value));4882
OX (get_vars().at(cursor->get_index() + USER_ARG_OFFSET) = cursor_value);
4888
int ObPLCodeGenerator::generate_open(
4889
const ObPLStmt &s, const ObPLSql &cursor_sql,
4890
const uint64_t package_id, const uint64_t routine_id, const int64_t cursor_index)
4892
int ret = OB_SUCCESS;
4893
if (NULL == get_current().get_v()) {4895
} else if (OB_FAIL(get_helper().set_insert_point(get_current()))) {4896
LOG_WARN("failed to set insert point", K(ret));4897
} else if (OB_FAIL(set_debug_location(s))) {4898
LOG_WARN("failed to set debug location", K(ret));4900
ObSEArray<ObLLVMValue, 8> args;
4901
//sql & ps_id & stmt_type & params & param count
4906
ObLLVMValue for_update;
4907
ObLLVMValue hidden_rowid;
4908
ObLLVMValue sql_params;
4909
ObLLVMValue sql_param_count;
4910
ObLLVMValue package_id_value;
4911
ObLLVMValue routine_id_value;
4912
ObLLVMValue cursor_index_value;
4913
ObLLVMValue formal_params;
4914
ObLLVMValue actual_params;
4915
ObLLVMValue cursor_param_count;
4916
ObLLVMValue skip_locked;
4917
ObLLVMValue ret_err;
4918
OZ (args.push_back(get_vars().at(CTX_IDX)));
4919
OZ (generate_sql(cursor_sql, str, len, ps_sql, type, for_update, hidden_rowid, sql_params,
4920
sql_param_count, skip_locked));
4921
OZ (args.push_back(str));
4922
OZ (args.push_back(ps_sql));
4923
OZ (args.push_back(type));
4924
OZ (args.push_back(for_update));
4925
OZ (args.push_back(hidden_rowid));
4926
OZ (args.push_back(sql_params));
4927
OZ (args.push_back(sql_param_count));
4928
OZ (get_helper().get_int64(package_id, package_id_value));
4929
OZ (args.push_back(package_id_value));
4930
OZ (get_helper().get_int64(routine_id, routine_id_value));
4931
OZ (args.push_back(routine_id_value));
4932
OZ (get_helper().get_int64(cursor_index, cursor_index_value));
4933
OZ (args.push_back(cursor_index_value));
4934
if (PL_OPEN == s.get_type() || PL_OPEN_FOR == s.get_type()) {4935
const ObPLOpenStmt &open_stmt = static_cast<const ObPLOpenStmt &>(s);
4936
const ObPLCursor *cursor = open_stmt.get_cursor();
4937
OZ (generate_int64_array(cursor->get_formal_params(), formal_params));
4938
OZ (generate_expression_array(static_cast<const ObPLOpenStmt&>(s).get_params(), actual_params, cursor_param_count));
4939
} else if (PL_CURSOR_FOR_LOOP == s.get_type()) {4940
const ObPLCursorForLoopStmt& for_stmt = static_cast<const ObPLCursorForLoopStmt&>(s);
4941
const ObPLCursor *cursor = for_stmt.get_cursor();
4942
OZ (generate_int64_array(cursor->get_formal_params(), formal_params));
4943
OZ (generate_expression_array(static_cast<const ObPLCursorForLoopStmt&>(s).get_params(), actual_params, cursor_param_count));
4944
} else { //must be OPEN FOR4945
OZ (generate_null_pointer(ObIntType, formal_params));
4946
OZ (generate_null_pointer(ObIntType, actual_params));
4947
OZ (helper_.get_int64(0, cursor_param_count));
4949
OZ (args.push_back(formal_params));
4950
OZ (args.push_back(actual_params));
4951
OZ (args.push_back(cursor_param_count));
4952
OZ (args.push_back(skip_locked));
4953
OZ (get_helper().create_call(ObString("spi_cursor_open"), get_spi_service().spi_cursor_open_, args, ret_err));4954
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
4959
int ObPLCodeGenerator::generate_open_for(const ObPLOpenForStmt &s)
4961
int ret = OB_SUCCESS;
4962
CK (OB_NOT_NULL(s.get_cursor()));
4963
// 这个不能，因为如果是ref cursor，这个ref count可能会有多个，这个调用会清零
4964
// 同时在ob_spi.cpp的 open_cursor_check函数中，reopen之前做了close操作
4965
OZ (generate_close(s,
4967
s.get_cursor()->get_routine_id(),
4969
true/*ignoe if not opened*/));
4971
if (s.is_dynamic()) {4972
if (NULL == get_current().get_v()) {4974
} else if (OB_FAIL(get_helper().set_insert_point(get_current()))) {4975
LOG_WARN("failed to set insert point", K(ret));4976
} else if (OB_FAIL(set_debug_location(s))) {4977
LOG_WARN("failed to set debug location", K(ret));4979
ObArray<int64_t> using_exprs;
4980
ObSEArray<ObLLVMValue, 8> args;
4981
ObLLVMValue sql_addr;
4982
ObLLVMValue sql_params;
4983
ObLLVMValue sql_param_count;
4984
ObLLVMValue package_id_value;
4985
ObLLVMValue routine_id_value;
4986
ObLLVMValue cursor_index_value;
4987
ObLLVMValue ret_err;
4988
OZ (args.push_back(get_vars().at(CTX_IDX)));
4989
OZ (generate_pointer(get_expr(s.get_dynamic_sql()), sql_addr));
4990
OZ (args.push_back(sql_addr));
4991
for (int64_t i = 0; OB_SUCC(ret) && i < s.get_using().count(); ++i) {4992
OZ (using_exprs.push_back(s.get_using_index(i)));
4994
OZ (generate_expression_array(using_exprs, sql_params, sql_param_count));
4995
OZ (args.push_back(sql_params));
4996
OZ (args.push_back(sql_param_count));
4997
OZ (get_helper().get_int64(s.get_cursor()->get_package_id(), package_id_value));
4998
OZ (args.push_back(package_id_value));
4999
OZ (get_helper().get_int64(s.get_cursor()->get_routine_id(), routine_id_value));
5000
OZ (args.push_back(routine_id_value));
5001
OZ (get_helper().get_int64(s.get_index(), cursor_index_value));
5002
OZ (args.push_back(cursor_index_value));
5003
OZ (get_helper().create_call(ObString("spi_dynamic_open"),5004
get_spi_service().spi_dynamic_open_, args, ret_err));
5005
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(),
5006
s.get_block()->in_warning()));
5011
s.get_cursor()->get_package_id(),
5012
s.get_cursor()->get_routine_id(),
5019
int ObPLCodeGenerator::generate_fetch(const ObPLStmt &s,
5020
const ObPLInto &into,
5021
const uint64_t &package_id,
5022
const uint64_t &routine_id,
5023
const int64_t &cursor_index,
5024
const int64_t &limit,
5025
const ObUserDefinedType *user_defined_type,
5026
jit::ObLLVMValue &ret_err)
5028
int ret = OB_SUCCESS;
5029
if (NULL == get_current().get_v()) {5031
} else if (OB_FAIL(get_helper().set_insert_point(get_current()))) {5032
LOG_WARN("failed to set insert point", K(ret));5033
} else if (OB_FAIL(set_debug_location(s))) {5034
LOG_WARN("failed to set debug location", K(ret));5036
ObSEArray<ObLLVMValue, 8> args;
5038
ObLLVMValue package_id_value;
5039
ObLLVMValue routine_id_value;
5040
ObLLVMValue cursor_index_value;
5041
OZ (args.push_back(get_vars().at(CTX_IDX)));
5042
OZ (get_helper().get_int64(package_id, package_id_value));
5043
OZ (args.push_back(package_id_value));
5044
OZ (get_helper().get_int64(routine_id, routine_id_value));
5045
OZ (args.push_back(routine_id_value));
5046
OZ (get_helper().get_int64(cursor_index, cursor_index_value));
5047
OZ (args.push_back(cursor_index_value));
5049
ObLLVMValue into_array_value;
5050
ObLLVMValue into_count_value;
5051
ObLLVMValue type_array_value;
5052
ObLLVMValue type_count_value;
5053
ObLLVMValue exprs_not_null_array_value;
5054
ObLLVMValue pl_integer_array_value;
5055
ObLLVMValue is_bulk, is_type_record;
5056
OZ (generate_into(into, into_array_value, into_count_value,
5057
type_array_value, type_count_value,
5058
exprs_not_null_array_value,
5059
pl_integer_array_value,
5061
OZ (args.push_back(into_array_value));
5062
OZ (args.push_back(into_count_value));
5063
OZ (args.push_back(type_array_value));
5064
OZ (args.push_back(type_count_value));
5065
OZ (args.push_back(exprs_not_null_array_value));
5066
OZ (args.push_back(pl_integer_array_value));
5067
OZ (args.push_back(is_bulk));
5071
ObLLVMValue limit_value;
5072
if (limit != INT64_MAX) {5073
ObLLVMBasicBlock null_block, not_null_block;
5074
ObLLVMValue p_limit_value, p_type_value, type_value, is_null;
5077
OZ (get_helper().create_block(ObString("null block"), get_func(), null_block));5078
OZ (get_helper().create_block(ObString("not null block"), get_func(), not_null_block));5080
OZ (generate_expr(limit, s, OB_INVALID_INDEX, p_limit_value));
5081
OZ (extract_type_ptr_from_objparam(p_limit_value, p_type_value));
5082
OZ (get_helper().create_load(ObString("load_type"), p_type_value, type_value));5083
OZ (get_helper().create_icmp_eq(type_value, ObNullType, is_null));
5084
OZ (get_helper().create_cond_br(is_null, null_block, not_null_block));
5086
OZ (set_current(null_block));
5087
OZ (get_helper().get_int32(OB_ERR_NULL_VALUE, result));
5088
OZ (check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5089
OZ (get_helper().create_br(not_null_block));
5091
OZ (set_current(not_null_block));
5092
CK (OB_NOT_NULL(s.get_expr(limit)));
5093
OZ (extract_value_from_objparam(p_limit_value, s.get_expr(limit)->get_data_type(), limit_value));
5095
OZ (get_helper().get_int64(limit, limit_value));
5097
OZ (args.push_back(limit_value));
5100
ObLLVMValue return_type_array_value;
5101
ObLLVMValue return_type_count_value;
5102
ObLLVMValue type_value;
5103
ObLLVMType data_type;
5104
ObLLVMType data_type_pointer;
5105
ObLLVMType array_type;
5107
if (OB_ISNULL(user_defined_type)) {5108
OZ (adt_service_.get_data_type(data_type));
5109
OZ (data_type.get_pointer_to(data_type_pointer));
5110
OZ (ObLLVMHelper::get_null_const(data_type_pointer, return_type_array_value));
5111
OZ (helper_.get_int64(0, return_type_count_value));
5113
const ObRecordType *return_type = static_cast<const ObRecordType*>(user_defined_type);
5114
const ObPLDataType *pl_data_type = nullptr;
5115
CK (OB_NOT_NULL(return_type));
5116
OZ (adt_service_.get_data_type(data_type));
5117
OZ (data_type.get_pointer_to(data_type_pointer));
5118
OZ (ObLLVMHelper::get_array_type(data_type,
5119
return_type->get_record_member_count(),
5121
OZ (helper_.create_alloca(ObString("datatype_array"),5123
return_type_array_value));
5125
for (int64_t i = 0; OB_SUCC(ret) && i < return_type->get_record_member_count(); ++i) {5127
OZ (helper_.create_gep(ObString("extract_datatype"),5128
return_type_array_value,
5130
pl_data_type = return_type->get_record_member_type(i);
5131
CK (OB_NOT_NULL(pl_data_type));
5133
if (pl_data_type->is_obj_type()) {5134
OZ (store_data_type(*(pl_data_type->get_data_type()), type_value));
5136
ObDataType ext_type;
5137
ext_type.set_obj_type(ObExtendType);
5138
OZ (store_data_type(ext_type, type_value));
5143
OZ (helper_.create_bit_cast(ObString("datatype_array_to_pointer"),5144
return_type_array_value, data_type_pointer, return_type_array_value));
5145
OZ (helper_.get_int64(static_cast<int64_t>(return_type->get_record_member_count()),
5146
return_type_count_value));
5149
OZ (args.push_back(return_type_array_value));
5150
OZ (args.push_back(return_type_count_value));
5151
OZ (helper_.get_int8(static_cast<int64_t>(into.is_type_record()), is_type_record));
5152
OZ (args.push_back(is_type_record));
5154
OZ (get_helper().create_call(ObString("spi_cursor_fetch"),5155
get_spi_service().spi_cursor_fetch_,
5161
int ObPLCodeGenerator::generate_close(const ObPLStmt &s,
5162
const uint64_t &package_id,
5163
const uint64_t &routine_id,
5164
const int64_t &cursor_index,
5168
int ret = OB_SUCCESS;
5169
if (NULL == get_current().get_v()) {5171
} else if (OB_FAIL(get_helper().set_insert_point(get_current()))) {5172
LOG_WARN("failed to set insert point", K(ret));5173
} else if (OB_FAIL(set_debug_location(s))) {5174
LOG_WARN("failed to set debug location", K(ret));5176
ObLLVMValue ret_err;
5177
ObSEArray<ObLLVMValue, 2> args;
5178
ObLLVMValue cursor_index_value, ignore_value;
5179
ObLLVMValue package_id_value;
5180
ObLLVMValue routine_id_value;
5181
OZ (args.push_back(get_vars().at(CTX_IDX)));
5182
OZ (get_helper().get_int64(package_id, package_id_value));
5183
OZ (args.push_back(package_id_value));
5184
OZ (get_helper().get_int64(routine_id, routine_id_value));
5185
OZ (args.push_back(routine_id_value));
5186
OZ (get_helper().get_int64(cursor_index, cursor_index_value));
5187
OZ (args.push_back(cursor_index_value));
5188
OZ (get_helper().get_int8(ignore, ignore_value));
5189
OZ (args.push_back(ignore_value));
5190
OZ (get_helper().create_call(ObString("spi_cursor_close"), get_spi_service().spi_cursor_close_, args, ret_err));5191
if (OB_SUCC(ret) && exception) {5192
OZ (check_success(ret_err,
5194
s.get_block()->in_notfound(),
5195
s.get_block()->in_warning()));
5201
int ObPLCodeGenerator::generate_check_not_null(const ObPLStmt &s,
5203
ObLLVMValue &p_result_obj)
5205
int ret = OB_SUCCESS;
5207
ObLLVMBasicBlock illegal_block, legal_block;
5208
ObLLVMBasicBlock check_composite, do_check_composite;
5209
ObLLVMValue p_type_value, type_value, is_null, is_extend;
5210
ObLLVMValue result, ret_err;
5211
ObSEArray<ObLLVMValue, 1> args;
5213
OZ (get_helper().create_block(ObString("illegal_block"), get_func(), illegal_block));5214
OZ (get_helper().create_block(ObString("legal_block"), get_func(), legal_block));5216
OZ (get_helper().create_block(ObString("check_composite"), get_func(), check_composite));5217
OZ (get_helper().create_block(ObString("do_check_composite"), get_func(), do_check_composite));5219
OZ (extract_type_ptr_from_objparam(p_result_obj, p_type_value));
5220
OZ (get_helper().create_load(ObString("load_type"), p_type_value, type_value));5221
OZ (get_helper().create_icmp_eq(type_value, ObNullType, is_null));
5222
OZ (get_helper().create_cond_br(is_null, illegal_block, check_composite));
5224
OZ (set_current(illegal_block));
5225
OZ (get_helper().get_int32(OB_ERR_NUMERIC_OR_VALUE_ERROR, result));
5226
OZ (check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5227
OZ (get_helper().create_br(legal_block));
5229
OZ (set_current(check_composite));
5230
OZ (get_helper().create_icmp_eq(type_value, ObExtendType, is_extend));
5231
OZ (get_helper().create_cond_br(is_extend, do_check_composite, legal_block));
5233
OZ (set_current(do_check_composite));
5234
OZ (args.push_back(p_result_obj));
5235
OZ (get_helper().create_call(ObString("spi_check_composite_not_null"),5236
get_spi_service().spi_check_composite_not_null_,
5239
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5240
OZ (get_helper().create_br(legal_block));
5242
OZ (set_current(legal_block));
5247
int ObPLCodeGenerator::generate_normal_next_and_check(const ObPLForLoopStmt &s,
5248
ObLLVMValue &p_index_obj,
5249
ObLLVMValue &p_index_value,
5250
ObLLVMValue &index_obj,
5251
ObLLVMValue &index_value,
5252
ObLLVMValue &dest_datum,
5253
ObLLVMValue &lower_value,
5254
ObLLVMValue &upper_value,
5255
ObLLVMValue &is_true)
5257
int ret = OB_SUCCESS;
5258
CK (OB_NOT_NULL(get_current().get_v()));
5259
// 对INDEX +1/-1 并将结果存储进param_store
5260
if (!s.get_reverse()) {5261
OZ (extract_value_ptr_from_obj(
5262
p_index_obj, s.get_lower_expr()->get_data_type(), p_index_value));
5263
OZ (get_helper().create_load(ObString("load_index_value"), p_index_value, index_value));5264
OZ (get_helper().create_inc(index_value, index_value));
5265
OZ (get_helper().create_store(index_value, p_index_value));
5266
OZ (cast_to_int64(p_index_value));
5267
OZ (get_helper().create_load(ObString("load_index_obj"), p_index_obj, index_obj));5268
OZ (get_helper().create_store(index_obj, dest_datum));
5269
OZ (get_helper().create_icmp(index_value, upper_value, ObLLVMHelper::ICMP_SLE, is_true));
5271
OZ (extract_value_ptr_from_obj(
5272
p_index_obj, s.get_upper_expr()->get_data_type(), p_index_value));
5273
OZ (get_helper().create_load(ObString("load_index_value"), p_index_value, index_value));5274
OZ (get_helper().create_dec(index_value, index_value));
5275
OZ (get_helper().create_store(index_value, p_index_value));
5276
OZ (cast_to_int64(p_index_value));
5277
OZ (get_helper().create_load(ObString("load_index_obj"), p_index_obj, index_obj));5278
OZ (get_helper().create_store(index_obj, dest_datum));
5279
OZ (get_helper().create_icmp(index_value, lower_value, ObLLVMHelper::ICMP_SGE, is_true));
5284
int ObPLCodeGenerator::generate_expr_next_and_check(const ObPLForLoopStmt &s,
5285
ObLLVMValue &p_index_obj,
5286
ObLLVMValue &p_index_value,
5287
ObLLVMValue &index_obj,
5288
ObLLVMValue &index_value,
5289
ObLLVMValue &dest_datum,
5290
ObLLVMValue &upper_value,
5291
ObLLVMValue &is_true)
5293
int ret = OB_SUCCESS;
5294
ObLLVMValue p_type_value, type_value, bool_value, p_is_continue_value;
5295
ObLLVMBasicBlock normal_block, not_null_block, continue_block, not_continue_block;
5297
CK (OB_NOT_NULL(s.get_next_expr()));
5298
OZ (get_helper().create_block(ObString("normal_block"), get_func(), normal_block));5299
OZ (get_helper().create_block(ObString("not_null_block"), get_func(), not_null_block));5300
OZ (get_helper().create_block(ObString("continue_block"), get_func(), continue_block));5301
OZ (get_helper().create_block(ObString("not_continue_block"), get_func(), not_continue_block));5303
OZ (get_helper().create_ialloca(
5304
ObString("p_is_continue_value"), ObTinyIntType, TRUE, p_is_continue_value));5305
if (s.is_values_bound()) {5306
OX (p_index_obj = get_vars().at(s.get_ident() + USER_ARG_OFFSET));
5307
OZ (get_helper().create_load(ObString("load_index_obj"), p_index_obj, index_obj));5308
OZ (get_helper().create_store(index_obj, dest_datum));
5311
OZ (generate_expr(s.get_next(), s, s.get_ident(), p_index_obj));
5312
if (s.is_values_bound()) {5313
ObLLVMValue p_tmp_obj;
5314
OX (p_tmp_obj = get_vars().at(s.get_ident() + USER_ARG_OFFSET));
5315
OZ (extract_obobj_from_objparam(p_index_obj, index_obj));
5316
OZ (get_helper().create_store(index_obj, p_tmp_obj));
5318
// 判断NextValue是否为Null, Null说明已经迭代到结尾
5319
OZ (extract_type_ptr_from_objparam(p_index_obj, p_type_value));
5320
OZ (get_helper().create_load(ObString("load_type"), p_type_value, type_value));5321
OZ (get_helper().create_icmp_eq(type_value, ObNullType, bool_value));
5322
OZ (get_helper().create_cond_br(bool_value, not_continue_block, not_null_block));
5323
// 不为Null还需要跟UpperValue做比较, 如果已经大于UpperValue, 也说明迭代到结尾了
5324
OZ (set_current(not_null_block));
5325
OZ (extract_value_ptr_from_objparam(
5326
p_index_obj, s.get_next_expr()->get_data_type(), p_index_value));
5327
OZ (get_helper().create_load(ObString("load_index_value"), p_index_value, index_value));5328
OZ (get_helper().create_icmp(index_value, upper_value, ObLLVMHelper::ICMP_SLE, bool_value));
5329
OZ (get_helper().create_cond_br(bool_value, continue_block, not_continue_block));
5330
// 设置is_true的值, 因为is_true不是指针, 因此在这个函数中仅能且必须被设置一次
5331
OZ (set_current(continue_block));
5332
OZ (get_helper().create_istore(TRUE, p_is_continue_value));
5333
OZ (get_helper().create_br(normal_block));
5334
OZ (set_current(not_continue_block));
5335
OZ (get_helper().create_istore(FALSE, p_is_continue_value));
5336
OZ (get_helper().create_br(normal_block));
5337
OZ (set_current(normal_block));
5338
OZ (get_helper().create_load(ObString("load_null_value"), p_is_continue_value, bool_value));5339
OZ (get_helper().create_icmp_eq(bool_value, TRUE, is_true));
5340
// 如果是values of子句, 需要将paramstore中index的位置赋值为数组的实际值而不是下标
5341
if (s.is_values_bound()) {5342
ObLLVMBasicBlock do_nothing_block, value_block;
5343
ObLLVMValue p_value;
5344
OZ (get_helper().create_block(
5345
ObString("do_nothing_block"), get_func(), do_nothing_block));5346
OZ (get_helper().create_block(
5347
ObString("value_block"), get_func(), value_block));5348
OZ (get_helper().create_cond_br(is_true, value_block, do_nothing_block));
5350
OZ (set_current(value_block));
5351
OZ (generate_expr(s.get_value(), s, s.get_ident(), p_value));
5352
OZ (get_helper().create_br(do_nothing_block));
5353
OZ (set_current(do_nothing_block));
5358
int ObPLCodeGenerator::generate_next_and_check(const ObPLForLoopStmt &s,
5359
ObLLVMValue &p_index_obj,
5360
ObLLVMValue &p_index_value,
5361
ObLLVMValue &index_obj,
5362
ObLLVMValue &index_value,
5363
ObLLVMValue &dest_datum,
5364
ObLLVMValue &lower_value,
5365
ObLLVMValue &upper_value,
5366
ObLLVMValue &is_true)
5368
int ret = OB_SUCCESS;
5369
if (s.is_normal_bound()) {5370
OZ (generate_normal_next_and_check(s,
5380
OZ (generate_expr_next_and_check(s,
5392
int ObPLCodeGenerator::generate_indices_with_between_bound(const ObPLForLoopStmt &s,
5393
ObLLVMValue &p_lower_obj)
5395
int ret = OB_SUCCESS;
5396
ObLLVMValue p_exist_obj, exist_obj, exist_value, is_exist;
5397
ObLLVMBasicBlock exist_block, not_exist_block;
5398
CK (get_current().get_v());
5399
OZ (get_helper().create_block(ObString("exist_block"),5402
OZ (get_helper().create_block(ObString("not_exist_block"),5405
OZ (generate_expr(s.get_exists(), s, OB_INVALID_INDEX, p_exist_obj));
5406
OZ (extract_value_from_objparam(
5407
p_exist_obj, s.get_exists_expr()->get_data_type(), exist_value));
5408
OZ (get_helper().create_icmp_eq(exist_value, TRUE, is_exist));
5409
OZ (get_helper().create_cond_br(is_exist, exist_block, not_exist_block));
5410
OZ (set_current(not_exist_block));
5411
OZ (generate_expr(s.get_next(), s, s.get_ident(), p_exist_obj));
5412
OZ (get_helper().create_load(ObString("load_exist_lower_obj"), p_exist_obj, exist_obj));5413
OZ (get_helper().create_store(exist_obj, p_lower_obj));
5414
OZ (get_helper().create_br(exist_block));
5415
OZ (set_current(exist_block));
5419
int ObPLCodeGenerator::generate_bound_and_check(const ObPLForLoopStmt &s,
5421
ObLLVMValue &lower_value, // lower value int64_t
5422
ObLLVMValue &upper_value, // upper value int64_t
5423
ObLLVMValue &lower_obj, // lower obj ObObject
5424
ObLLVMValue &upper_obj, // upper obj ObObject
5425
ObLLVMBasicBlock &illegal_range_block) // ret_err int32_t
5427
int ret = OB_SUCCESS;
5428
if (get_current().get_v()) {5431
OZ (get_helper().set_insert_point(get_current()));
5432
OZ (set_debug_location(s));
5435
ObLLVMBasicBlock check_null_block, illegal_null_block, body_block, check_up_low_block;
5436
ObLLVMValue p_lower_obj, p_upper_obj;
5437
ObSEArray<ObLLVMValue, 5> args;
5440
CK (OB_NOT_NULL(s.get_body()));
5441
CK (OB_NOT_NULL(s.get_lower_expr()));
5442
CK (OB_NOT_NULL(s.get_upper_expr()));
5444
OZ (get_helper().create_block(ObString("check_null_block"),5447
OZ (get_helper().create_block(ObString("body_block"),5450
OZ (get_helper().create_block(ObString("check_up_low_block"),5452
check_up_low_block));
5453
OZ (get_helper().create_block(ObString("illegal_null_block"),5455
illegal_null_block));
5458
OZ (generate_expr(s.get_lower(), s, s.get_ident(), p_lower_obj));
5459
OZ (generate_expr(s.get_upper(), s, OB_INVALID_INDEX, p_upper_obj));
5461
if (s.is_indices_with_between_bound()) {5462
OZ (generate_indices_with_between_bound(s, p_lower_obj));
5466
// 在FORALL中上界或者下界为NULL, 不报错
5467
// 在FORLOOP中上界或者下界为NULL, 报错
5468
// 如果上界下界均不为NULL, 不报错, 范围不符合条件什么都不做
5469
ObLLVMValue p_type_value, type_value, is_null, is_legal;
5470
OZ (get_helper().get_int32(OB_SUCCESS, result));
5472
OZ (extract_type_ptr_from_objparam(p_lower_obj, p_type_value));
5473
OZ (get_helper().create_load(ObString("load_type"), p_type_value, type_value));5474
OZ (get_helper().create_icmp_eq(type_value, ObNullType, is_null));
5475
OZ (get_helper().create_cond_br(is_null, illegal_null_block, check_null_block));
5477
OZ (get_helper().set_insert_point(check_null_block));
5478
OZ (extract_type_ptr_from_objparam(p_upper_obj, p_type_value));
5479
OZ (get_helper().create_load(ObString("load_type"), p_type_value, type_value));5480
OZ (get_helper().create_icmp_eq(type_value, ObNullType, is_null));
5481
OZ (get_helper().create_cond_br(is_null, illegal_null_block, check_up_low_block));
5483
OZ (set_current(illegal_null_block));
5484
OZ (get_helper().get_int32(OB_ERR_NULL_VALUE, result));
5486
OZ (check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5488
OZ (get_helper().create_br(illegal_range_block));
5490
OZ (get_helper().set_insert_point(check_up_low_block));
5491
OZ (extract_value_from_objparam(p_lower_obj, s.get_lower_expr()->get_data_type(), lower_value));
5492
OZ (extract_datum_from_objparam(p_lower_obj, s.get_lower_expr()->get_data_type(), lower_obj));
5493
OZ (extract_value_from_objparam(p_upper_obj, s.get_upper_expr()->get_data_type(), upper_value));
5494
OZ (extract_datum_from_objparam(p_upper_obj, s.get_upper_expr()->get_data_type(), upper_obj));
5496
* Without REVERSE, the value of index starts at lower_bound and increases by one with
5497
* each iteration of the loop until it reaches upper_bound. If lower_bound is greater than
5498
* upper_bound, then the statements never run.
5499
* With REVERSE, the value of index starts at upper_bound and decreases by one with each
5500
* iteration of the loop until it reaches lower_bound. If upper_bound is less than lower_
5501
* bound, then the statements never run.
5503
OZ (get_helper().create_icmp(lower_value, upper_value, ObLLVMHelper::ICMP_SLE, is_legal));
5504
OZ (get_helper().create_cond_br(is_legal, body_block, illegal_range_block));
5506
OZ (set_current(body_block));
5509
if (OB_SUCC(ret) && is_forall) {5510
const ObPLForAllStmt *forall_stmt = static_cast<const ObPLForAllStmt*>(&s);
5511
CK (OB_NOT_NULL(forall_stmt));
5513
ObLLVMValue src_idx_value, dst_idx_value, ret_err;
5514
ObSEArray<ObLLVMValue, 5> args;
5515
const hash::ObHashMap<int64_t, int64_t> &sub_map = forall_stmt->get_tab_to_subtab_map();
5516
for (hash::ObHashMap<int64_t, int64_t>::const_iterator it = sub_map.begin();
5517
OB_SUCC(ret) && it != sub_map.end(); ++it) {5519
int64_t src_idx = (*it).first;
5520
int64_t dst_idx = (*it).second;
5521
OZ (get_helper().get_int64(src_idx, src_idx_value));
5522
OZ (get_helper().get_int64(dst_idx, dst_idx_value));
5523
OZ (args.push_back(get_vars().at(CTX_IDX)));
5524
OZ (args.push_back(src_idx_value));
5525
OZ (args.push_back(dst_idx_value));
5526
OZ (args.push_back(lower_value));
5527
OZ (args.push_back(upper_value));
5528
OZ (get_helper().create_call(ObString("spi_sub_nestedtable"),5529
get_spi_service().spi_sub_nestedtable_,
5532
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5540
int ObPLCodeGenerator::generate_sql(const ObPLSqlStmt &s, ObLLVMValue &ret_err)
5542
int ret = OB_SUCCESS;
5543
if (OB_ISNULL(get_current().get_v())) {5546
OZ (get_helper().set_insert_point(get_current()));
5547
OZ (set_debug_location(s));
5550
} else if (stmt::T_END_TRANS == s.get_stmt_type()) {5551
bool is_rollback = false;
5552
ObSEArray<ObLLVMValue, 2> args;
5553
ObLLVMValue is_rollback_value, sql, length;
5554
// only allow stmt here: COMMIT; COMMIT COMMENT 'X'; ROLLBACK;
5555
// COMMIT WORK; ROLLBACK WORK;
5556
CK (((s.get_sql().length() >= 5 && 0 == STRNCASECMP(s.get_sql().ptr(), "commit", 5))
5557
|| (s.get_sql().length() >= 8 && 0 == STRNCASECMP(s.get_sql().ptr(), "rollback", 8))));
5559
= (s.get_sql().length() >= 8 && 0 == STRNCASECMP(s.get_sql().ptr(), "rollback", 8)));
5560
OZ (generate_string(s.get_sql(), sql, length));
5561
OZ (args.push_back(get_vars().at(CTX_IDX)));
5562
OZ (args.push_back(sql));
5563
OZ (get_helper().get_int8(is_rollback, is_rollback_value));
5564
OZ (args.push_back(is_rollback_value));
5565
OZ (get_helper().create_call(ObString("spi_end_trans"), get_spi_service().spi_end_trans_, args, ret_err));5566
LOG_DEBUG("explicit end trans in pl", K(ret), K(s.get_sql()));5568
ObSEArray<ObLLVMValue, 16> args;
5573
ObLLVMValue for_update;
5574
ObLLVMValue hidden_rowid;
5576
ObLLVMValue count, is_type_record;
5577
ObLLVMValue skip_locked;
5578
OZ (args.push_back(get_vars().at(CTX_IDX)));
5579
OZ (generate_sql(s, str, len, ps_sql, type, for_update, hidden_rowid, params, count, skip_locked));
5581
if (s.get_params().empty()) {5582
OZ (args.push_back(str));
5583
OZ (args.push_back(type));
5585
OZ (args.push_back(ps_sql));
5586
OZ (args.push_back(type));
5587
OZ (args.push_back(params));
5588
OZ (args.push_back(count));
5592
ObLLVMValue into_array_value;
5593
ObLLVMValue into_count_value;
5594
ObLLVMValue type_array_value;
5595
ObLLVMValue type_count_value;
5596
ObLLVMValue exprs_not_null_array_value;
5597
ObLLVMValue pl_integer_range_array_value;
5598
ObLLVMValue is_bulk;
5599
OZ (generate_into(s, into_array_value, into_count_value,
5600
type_array_value, type_count_value,
5601
exprs_not_null_array_value,
5602
pl_integer_range_array_value,
5604
OZ (args.push_back(into_array_value));
5605
OZ (args.push_back(into_count_value));
5606
OZ (args.push_back(type_array_value));
5607
OZ (args.push_back(type_count_value));
5608
OZ (args.push_back(exprs_not_null_array_value));
5609
OZ (args.push_back(pl_integer_range_array_value));
5610
OZ (args.push_back(is_bulk));
5613
if (s.get_params().empty()) {5614
OZ (get_helper().get_int8(static_cast<int64_t>(s.is_type_record()), is_type_record));
5615
OZ (args.push_back(is_type_record));
5616
OZ (args.push_back(for_update));
5617
OZ (get_helper().create_call(ObString("spi_query"), get_spi_service().spi_query_, args, ret_err));5618
} else { //有外部变量，走prepare/execute接口5619
ObLLVMValue is_forall;
5620
OZ (get_helper().get_int8(static_cast<int64_t>(s.is_forall_sql()), is_forall));
5621
OZ (args.push_back(is_forall));
5622
OZ (get_helper().get_int8(static_cast<int64_t>(s.is_type_record()), is_type_record));
5623
OZ (args.push_back(is_type_record));
5624
OZ (args.push_back(for_update));
5625
OZ (get_helper().create_call(ObString("spi_execute"), get_spi_service().spi_execute_, args, ret_err));5632
int ObPLCodeGenerator::generate_after_sql(const ObPLSqlStmt &s, ObLLVMValue &ret_err)
5634
int ret = OB_SUCCESS;
5635
if (OB_ISNULL(get_current().get_v())) {5638
OZ (check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
5639
OZ (generate_into_restore(s.get_into(), s.get_exprs(), s.get_symbol_table()));
5640
if (OB_SUCC(ret) && lib::is_mysql_mode()) {5641
ObLLVMValue is_not_found;
5642
ObLLVMBasicBlock normal_end;
5643
ObLLVMBasicBlock reset_ret;
5644
ObLLVMValue ret_success;
5645
OZ (get_helper().create_block(ObString("sql_end"), get_func(), normal_end));5646
OZ (get_helper().create_block(ObString("sql_check_success"), get_func(), reset_ret));5647
OZ (get_helper().create_icmp_eq(ret_err, OB_READ_NOTHING, is_not_found));
5648
OZ (get_helper().create_cond_br(is_not_found, reset_ret, normal_end));
5649
OZ (get_helper().set_insert_point(reset_ret));
5650
OZ (get_helper().get_int32(OB_SUCCESS, ret_success));
5651
OZ (get_helper().create_store(ret_success, get_vars().at(RET_IDX)));
5652
OZ (get_helper().create_br(normal_end));
5653
OZ (set_current(normal_end));
5659
int ObPLCodeGenerator::get_llvm_type(const ObPLDataType &pl_type, ObLLVMType &ir_type)
5661
int ret = OB_SUCCESS;
5663
if (pl_type.is_obj_type()) {5664
if (OB_FAIL(ObPLDataType::get_llvm_type(pl_type.get_obj_type(), get_helper(), get_adt_service(), ir_type))) {5665
LOG_WARN("failed to get datum type", K(ret));5667
} else if (pl_type.is_user_type()) {5668
uint64_t user_type_id = pl_type.get_user_type_id();
5669
if (OB_FAIL(get_user_type_map().get_refactored(user_type_id, ir_type))) {5670
LOG_WARN("get user type map failed", K(ret), K(user_type_id));5673
ret = OB_ERR_UNEXPECTED;
5674
LOG_WARN("pl type is invalid", K(pl_type.get_type()));5679
int ObPLCodeGenerator::get_datum_type(const ObPLDataType &pl_type, ObLLVMType &ir_type)
5681
int ret = OB_SUCCESS;
5683
// if (pl_type.is_obj_type()) {5684
if (OB_FAIL(ObPLDataType::get_datum_type(pl_type.get_obj_type(), helper_, adt_service_, ir_type))) { //集合类型里的基础数据类型统一用int64存储5685
LOG_WARN("failed to get datum type", K(ret));5687
// } else if (pl_type.is_user_type()) {5688
// uint64_t user_type_id = pl_type.get_user_type_id();
5689
// if (OB_FAIL(user_type_map_.get_refactored(user_type_id, ir_type))) {5690
// LOG_WARN("get user type map failed", K(ret), K(user_type_id));5693
// ret = OB_ERR_UNEXPECTED;
5694
// LOG_WARN("pl type is invalid", K(pl_type.get_type()));5699
int ObPLCodeGenerator::generate_string(const ObString &string, ObLLVMValue &str, ObLLVMValue &len)
5701
int ret = OB_SUCCESS;
5702
if (string.empty()) {5703
if (OB_FAIL(generate_empty_string(str, len))) {5704
LOG_WARN("failed to generate_empty_string", K(ret));5707
ObLLVMValue llvm_string;
5708
ObLLVMType llvm_string_type;
5709
ObLLVMValue p_llvm_string;
5710
ObLLVMType llvm_type;
5711
OZ (helper_.get_llvm_type(ObCharType, llvm_type));
5712
OZ (helper_.get_string(string, llvm_string));
5713
OZ (llvm_string.get_type(llvm_string_type));
5714
OZ (helper_.create_alloca(ObString("string"), llvm_string_type, p_llvm_string));5715
OZ (helper_.create_store(llvm_string, p_llvm_string));
5716
OZ (helper_.create_pointer_cast(ObString("string_to_char"), p_llvm_string, llvm_type, str));5718
OZ (helper_.get_int64(string.length(), len));
5723
int ObPLCodeGenerator::generate_global_string(const ObString &string, ObLLVMValue &str, ObLLVMValue &len)
5725
int ret = OB_SUCCESS;
5726
if (string.empty()) {5727
OZ (generate_empty_string(str, len));
5729
ObLLVMType llvm_type;
5730
ObLLVMValue llvm_string;
5731
OZ (helper_.get_llvm_type(ObCharType, llvm_type));
5732
OZ (helper_.get_string(string, llvm_string));
5733
OZ (helper_.get_global_string(llvm_string, llvm_string));
5734
OZ (helper_.create_pointer_cast(ObString("string_to_char"), llvm_string, llvm_type, str));5735
OZ (helper_.get_int64(string.length(), len));
5740
int ObPLCodeGenerator::generate_empty_string(ObLLVMValue &str, ObLLVMValue &len)
5742
int ret = OB_SUCCESS;
5743
ObLLVMType llvm_type;
5744
if (OB_FAIL(helper_.get_llvm_type(ObCharType, llvm_type))) {5745
LOG_WARN("failed to get_llvm_type", K(ret));5746
} else if (OB_FAIL(ObLLVMHelper::get_null_const(llvm_type, str))) {5747
LOG_WARN("failed to get_null_const", K(ret));5748
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, llvm_type))) {5749
LOG_WARN("failed to get_llvm_type", K(ret));5750
} else if (OB_FAIL(ObLLVMHelper::get_null_const(llvm_type, len))) {5751
LOG_WARN("failed to get_null_const", K(ret));5752
} else { /*do nothing*/ }5756
int ObPLCodeGenerator::generate_null(ObObjType type, ObLLVMValue &value)
5758
int ret = OB_SUCCESS;
5759
ObLLVMType llvm_type;
5760
if (OB_FAIL(helper_.get_llvm_type(type, llvm_type))) {5761
LOG_WARN("failed to get_llvm_type", K(ret));5762
} else if (OB_FAIL(ObLLVMHelper::get_null_const(llvm_type, value))) {5763
LOG_WARN("failed to get_null_const", K(ret));5764
} else { /*do nothing*/ }5768
int ObPLCodeGenerator::generate_null_pointer(ObObjType type, ObLLVMValue &value)
5770
int ret = OB_SUCCESS;
5771
ObLLVMType llvm_type;
5772
ObLLVMType llvm_pointer_type;
5773
if (OB_FAIL(helper_.get_llvm_type(type, llvm_type))) {5774
LOG_WARN("failed to get_llvm_type", K(ret));5775
} else if (OB_FAIL(llvm_type.get_pointer_to(llvm_pointer_type))) {5776
LOG_WARN("failed to get_pointer_to", K(ret));5777
} else if (OB_FAIL(ObLLVMHelper::get_null_const(llvm_pointer_type, value))) {5778
LOG_WARN("failed to get_null_const", K(ret));5779
} else { /*do nothing*/ }5783
int ObPLCodeGenerator::generate_int64_array(const ObIArray<int64_t> &array, ObLLVMValue &result)
5785
int ret = OB_SUCCESS;
5786
ObArray<uint64_t> uint64_array;
5787
for (int64_t i = 0; OB_SUCC(ret) && i < array.count(); ++i) {5788
uint64_t v = array.at(i);
5789
OZ (uint64_array.push_back(v));
5791
OZ (generate_uint64_array(uint64_array, result));
5795
int ObPLCodeGenerator::generate_uint64_array(const ObIArray<uint64_t> &array, ObLLVMValue &result)
5797
int ret = OB_SUCCESS;
5798
if (array.empty()) {5799
OZ (generate_null_pointer(ObIntType, result));
5801
ObLLVMValue llvm_array;
5802
if (OB_FAIL(helper_.get_uint64_array(array, llvm_array))) {5803
LOG_WARN("failed to get_uint64_array", K(ret));5804
} else if (OB_FAIL(generate_array(llvm_array, result))) {5805
LOG_WARN("failed to generate_array", K(ret));5806
} else { /*do nothing*/ }5811
int ObPLCodeGenerator::generate_array(const ObLLVMValue array, ObLLVMValue &result)
5813
int ret = OB_SUCCESS;
5814
ObSEArray<int64_t, 2> indices;
5815
ObLLVMType array_type;
5816
ObLLVMValue p_array;
5817
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(0))) {5818
LOG_WARN("push_back error", K(ret));5819
} else if (OB_FAIL(array.get_type(array_type))) {5820
LOG_WARN("failed to get_type", K(ret));5821
} else if (OB_FAIL(helper_.create_alloca(ObString("array"), array_type, p_array))) {5822
LOG_WARN("failed to create_alloca", K(ret));5823
} else if (OB_FAIL(helper_.create_store(array, p_array))) {5824
LOG_WARN("failed to create_store", K(ret));5825
} else if (OB_FAIL(helper_.create_gep(ObString("extract_first_addr_from_array"), p_array, indices, result))) {5826
LOG_WARN("failed to create_gep", K(ret));5827
} else { /*do nothing*/ }5832
int ObPLCodeGenerator::generate_debug(const ObString &name, int64_t value)
5834
int ret = OB_SUCCESS;
5835
ObLLVMValue int_value;
5836
OZ (helper_.get_int64(value, int_value));
5837
OZ (generate_debug(name, int_value));
5840
int ObPLCodeGenerator::generate_debug(const ObString &name, ObLLVMValue &value)
5842
int ret = OB_SUCCESS;
5843
ObSEArray<ObLLVMValue, 4> args;
5846
OZ (generate_string(name, str, len));
5847
OZ (args.push_back(str));
5848
OZ (args.push_back(len));
5849
OZ (args.push_back(value));
5850
if (12 == value.get_type_id()) { //12 is IntegerTyID5851
switch (value.get_type().get_width()) {5853
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int8_, args));5857
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int32_, args));5861
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int64_, args));5865
ret = OB_INVALID_ARGUMENT;
5866
LOG_WARN("Unexpected integer to debug", K(value.get_type().get_width()), K(ret));5870
} else if (14 == value.get_type_id() && 12 == value.get_type().get_child(0).get_id()) { //14 is PointerTyID5871
switch (value.get_type().get_child(0).get_width()) {5873
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int8ptr_, args));5877
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int32ptr_, args));5881
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int64ptr_, args));5885
ret = OB_INVALID_ARGUMENT;
5886
LOG_WARN("Unexpected integer pointer to debug", K(value.get_type().get_width()), K(ret));5890
} else if (14 == value.get_type_id() && 15 == value.get_type().get_child(0).get_id()) { //14 is PointerTyID, 15 is StructTyID5891
ObLLVMType obj_type;
5892
ObLLVMType objparam_type;
5893
OZ (adt_service_.get_obj(obj_type));
5894
OZ (adt_service_.get_objparam(objparam_type));
5896
bool is_same = false;
5897
OZ (value.get_type().get_child(0).same_as(obj_type, is_same));
5900
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_obj_, args));5902
OZ (value.get_type().get_child(0).same_as(objparam_type, is_same));
5905
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_objparam_, args));5907
ObLLVMType int_type;
5908
ObLLVMValue int_value;
5909
OZ (helper_.get_llvm_type(ObIntType, int_type));
5910
OZ (helper_.create_ptr_to_int(ObString("object_to_int64"),5914
OX (args.at(2) = int_value);
5915
OZ (helper_.create_call(ObString("debug"), get_eh_service().eh_debug_int64_, args));5922
ret = OB_INVALID_ARGUMENT;
5923
LOG_WARN("Unexpected value to debug", K(value.get_type_id())/*, K(value.get_type().get_child(0).get_id()), K(ret)*/);5928
#define STORE_META(first, second, name, get_func) \
5930
if (OB_SUCC(ret)) { \5932
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(first)) || OB_FAIL(indices.push_back(second))) { \5933
LOG_WARN("push_back error", K(ret)); \5934
} else if (OB_FAIL(helper_.create_gep(ObString(name), p_obj, indices, dest))) { \5935
LOG_WARN("failed to create gep", K(ret)); \5936
} else if (OB_FAIL(helper_.get_int8(meta.get_func(), src))) { \5937
LOG_WARN("failed to get_int64", K(meta.get_type()), K(meta), K(ret)); \5938
} else if (OB_FAIL(helper_.create_store(src, dest))) { \5939
LOG_WARN("failed to create store", K(ret)); \5940
} else { /*do nothing*/ } \5944
#define STORE_ELEMENT(idx, name, get_func, length) \
5946
if (OB_SUCC(ret)) { \5947
if (OB_FAIL(helper_.create_gep(ObString(name), p_obj, idx, dest))) { \5948
LOG_WARN("failed to create gep", K(ret)); \5949
} else if (OB_FAIL(helper_.get_int##length(object.get_func(), src))) { \5950
LOG_WARN("failed to get_int64", K(object), K(ret)); \5951
} else if (OB_FAIL(helper_.create_store(src, dest))) { \5952
LOG_WARN("failed to create store", K(ret)); \5953
} else { /*do nothing*/ } \5957
int ObPLCodeGenerator::generate_obj(const ObObj &object, ObLLVMValue &result)
5959
int ret = OB_SUCCESS;
5960
ObLLVMType obj_type;
5961
if (OB_FAIL(adt_service_.get_obj(obj_type))) {5962
LOG_WARN("failed to get_llvm_type", K(ret));5963
} else if (OB_FAIL(helper_.create_alloca(ObString("ObObj"), obj_type, result))) {5964
LOG_WARN("failed to create_alloca", K(ret));5965
} else if (OB_FAIL(store_obj(object, result))) {5966
LOG_WARN("failed to store obj", K(ret));5967
} else { /*do nothing*/ }5971
int ObPLCodeGenerator::store_obj(const ObObj &object, ObLLVMValue &p_obj)
5973
int ret = OB_SUCCESS;
5974
const ObObjMeta &meta = object.get_meta();
5975
ObSEArray<int64_t, 3> indices;
5979
STORE_META(0, 0, "extract_obj_type", get_type);
5981
STORE_META(0, 1, "extract_obj_collation_level", get_collation_level);
5983
STORE_META(0, 2, "extract_obj_collation_type", get_collation_type);
5985
STORE_META(0, 3, "extract_obj_scale", get_scale);
5987
STORE_ELEMENT(1, "extract_obj_length", get_val_len, 32);
5989
STORE_ELEMENT(2, "extract_obj_value", get_int, 64);
5994
int ObPLCodeGenerator::store_objparam(const ObObjParam &object, ObLLVMValue &p_objparam)
5996
int ret = OB_SUCCESS;
5998
if (OB_FAIL(helper_.create_gep(ObString("extract_obj_pointer"), p_objparam, 0, p_obj))) {5999
LOG_WARN("failed to create gep", K(ret));6000
} else if (OB_FAIL(store_obj(object, p_obj))) {6001
LOG_WARN("failed to store obj", K(ret));6002
} else { /*do nothing*/ }6006
int ObPLCodeGenerator::store_data_type(const ObDataType &object, jit::ObLLVMValue &p_obj)
6008
int ret = OB_SUCCESS;
6009
const ObObjMeta &meta = object.get_meta_type();
6010
ObSEArray<int64_t, 2> indices;
6014
STORE_META(0, 0, "extract_obj_type", get_type);
6016
STORE_META(0, 1, "extract_obj_collation_level", get_collation_level);
6018
STORE_META(0, 2, "extract_obj_collation_type", get_collation_type);
6020
STORE_META(0, 3, "extract_obj_scale", get_scale);
6022
STORE_ELEMENT(1, "extract_accuracy", get_accuracy_value, 64);
6024
STORE_ELEMENT(2, "extract_charset", get_charset_type, 32);
6025
//is_binary_collation
6026
STORE_ELEMENT(3, "extract_binary_collation", is_binary_collation, 8);
6028
STORE_ELEMENT(4, "extract_zero_fill", is_zero_fill, 8);
6032
int ObPLCodeGenerator::store_elem_desc(const ObElemDesc &object, jit::ObLLVMValue &p_obj)
6034
int ret = OB_SUCCESS;
6037
OZ (store_data_type(object, p_obj));
6039
STORE_ELEMENT(5, "extract_pl_type", get_pl_type, 32);
6041
STORE_ELEMENT(6, "extract_not_null", is_not_null, 8);
6043
STORE_ELEMENT(7, "extract_field_count", get_field_count, 32);
6047
#define GENERATE_OBJECT(name, class) \
6048
int ObPLCodeGenerator::generate_##name(const class &object, jit::ObLLVMValue &result) \
6050
int ret = OB_SUCCESS; \
6051
ObLLVMType object_type; \
6052
if (OB_FAIL(adt_service_.get_##name(object_type))) { \6053
LOG_WARN("failed to get_llvm_type", K(ret)); \6054
} else if (OB_FAIL(helper_.create_alloca(ObString("NewObject"), object_type, result))) { \6055
LOG_WARN("failed to create_alloca", K(ret)); \6056
} else if (OB_FAIL(store_##name(object, result))) { \6057
LOG_WARN("failed to store", K(ret)); \6058
} else { /*do nothing*/ } \6062
GENERATE_OBJECT(data_type, ObDataType)
6063
GENERATE_OBJECT(elem_desc, ObElemDesc)
6065
#define INIT_OBJPARAM_ELEMENT(name, length, value) \
6067
if (OB_SUCC(ret)) { \6068
if (OB_FAIL(extract_##name##_ptr_from_objparam(result, dest))) { \6069
LOG_WARN("failed to extract ptr from objparam", K(ret)); \6070
} else if (OB_FAIL(helper_.get_int##length(value, src))) { \6071
LOG_WARN("failed to get_int8", K(ret)); \6072
} else if (OB_FAIL(helper_.create_store(src, dest))) { \6073
LOG_WARN("failed to create_store", K(ret)); \6074
} else { /*do nothing*/ } \6078
int ObPLCodeGenerator::generate_new_objparam(ObLLVMValue &result, int64_t udt_id)
6080
int ret = OB_SUCCESS;
6081
ObLLVMType objparam_type;
6082
ObLLVMValue const_value;
6083
if (OB_FAIL(adt_service_.get_objparam(objparam_type))) {6084
LOG_WARN("failed to get_llvm_type", K(ret));6085
} else if (OB_FAIL(helper_.create_alloca(ObString("ObObjParam"), objparam_type, result))) {6086
LOG_WARN("failed to create_alloca", K(ret));6087
} else if (OB_FAIL(ObLLVMHelper::get_null_const(objparam_type, const_value))) {6088
LOG_WARN("failed to get_null_const", K(ret));6089
} else if (OB_FAIL(helper_.create_store(const_value, result))) {6090
LOG_WARN("failed to create_store", K(ret));6095
INIT_OBJPARAM_ELEMENT(cslevel, 8, ObCollationLevel::CS_LEVEL_INVALID);
6097
INIT_OBJPARAM_ELEMENT(scale, 8, -1);
6099
INIT_OBJPARAM_ELEMENT(accuracy, 64, udt_id);
6101
INIT_OBJPARAM_ELEMENT(flag, 8, 1);
6103
INIT_OBJPARAM_ELEMENT(raw_text_pos, 32, -1);
6105
INIT_OBJPARAM_ELEMENT(raw_text_len, 32, -1);
6107
INIT_OBJPARAM_ELEMENT(type, 8, 0);
6108
INIT_OBJPARAM_ELEMENT(cslevel, 8, 7);
6109
INIT_OBJPARAM_ELEMENT(cstype, 8, 0);
6110
INIT_OBJPARAM_ELEMENT(scale, 8, -1);
6115
int ObPLCodeGenerator::generate_set_extend(ObLLVMValue &p_obj,
6120
int ret = OB_SUCCESS;
6121
ObLLVMValue var_type;
6122
ObLLVMValue init_value;
6123
ObLLVMValue extend_value;
6124
OZ (get_helper().get_int8(type, var_type));
6125
OZ (get_helper().get_int32(size, init_value));
6126
OZ (get_helper().get_int32(ptr, extend_value));
6127
OZ (generate_set_extend(p_obj, var_type, init_value, extend_value));
6132
int ObPLCodeGenerator::generate_set_extend(ObLLVMValue &p_obj,
6137
int ret = OB_SUCCESS;
6138
ObSEArray<int64_t, 3> indices;
6142
ObObj extend_obj(ObExtendType);
6143
extend_obj.set_int_value(0);
6144
OZ (store_obj(extend_obj, p_obj));
6147
OZ (indices.push_back(0));
6148
OZ (indices.push_back(0));
6149
OZ (indices.push_back(3));
6150
OZ (helper_.create_gep("extend_type", p_obj, indices, dest));6151
OZ (helper_.create_store(type, dest));
6154
OZ (helper_.create_gep("extend_type", p_obj, 1, dest));6155
OZ (helper_.create_store(size, dest));
6158
OZ (helper_.create_gep("extend_type", p_obj, 2, dest));6159
OZ (helper_.create_store(ptr, dest));
6164
int ObPLCodeGenerator::generate_spi_calc(int64_t expr_idx,
6169
ObLLVMValue &p_result_obj)
6171
int ret = OB_SUCCESS;
6172
const ObSqlExpression *expr = get_expr(expr_idx);
6173
if (OB_ISNULL(expr)) {6174
ret = OB_ERR_UNEXPECTED;
6175
LOG_WARN("expr is NULL", K(ret));6177
ObLLVMValue expr_addr;
6178
if (OB_FAIL(generate_pointer(expr, expr_addr))) {6179
LOG_WARN("failed to generate a pointer", K(ret));6181
ObSEArray<ObLLVMValue, 4> args;
6183
ObLLVMValue int_value;
6184
ObLLVMValue package_id;
6185
int64_t udt_id = ast_.get_expr(expr_idx)->get_result_type().get_udt_id();
6187
if (OB_FAIL(args.push_back(vars_.at(CTX_IDX)))) { //PL的执行环境6188
LOG_WARN("push_back error", K(ret));6189
} else if (OB_FAIL(args.push_back(expr_addr))) { //表达式的绝对地址6190
LOG_WARN("push_back error", K(ret));6191
} else if (OB_FAIL(helper_.get_int64(result_idx, int_value))) {6192
LOG_WARN("failed to get int64", K(ret));6193
} else if (OB_FAIL(args.push_back(int_value))) { //结果在ObArray里的位置6194
LOG_WARN("push_back error", K(ret));6195
} else if (OB_FAIL(generate_new_objparam(p_result_obj, udt_id))) {6196
LOG_WARN("failed to generate_new_objparam", K(ret));6197
} else if (OB_FAIL(args.push_back(p_result_obj))) {6198
LOG_WARN("push_back error", K(ret));6199
} else if (OB_FAIL(helper_.create_call(ObString("calc_expr"), get_spi_service().spi_calc_expr_, args, result))) {6200
LOG_WARN("failed to create call", K(ret));6201
} else if (OB_FAIL(check_success(result, stmt_id, in_notfound, in_warning))) {6202
LOG_WARN("failed to check success", K(ret));6203
} else { /*do nothing*/ }6209
int ObPLCodeGenerator::generate_spi_package_calc(uint64_t package_id,
6212
ObLLVMValue &p_result_obj)
6214
int ret = OB_SUCCESS;
6215
ObSEArray<ObLLVMValue, 4> args;
6217
ObLLVMValue v_package_id;
6218
ObLLVMValue v_expr_idx;
6219
CK (OB_NOT_NULL(s.get_block()));
6220
OZ (args.push_back(vars_.at(CTX_IDX)));
6221
OZ (helper_.get_int64(package_id, v_package_id));
6222
OZ (helper_.get_int64(expr_idx, v_expr_idx));
6223
OZ (args.push_back(v_package_id));
6224
OZ (args.push_back(v_expr_idx));
6225
OZ (generate_new_objparam(p_result_obj));
6226
OZ (args.push_back(p_result_obj));
6227
OZ (helper_.create_call(ObString("calc_package_expr"), get_spi_service().spi_calc_package_expr_, args, result));6228
OZ (check_success(result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
6232
int ObPLCodeGenerator::generate_llvm_calc(int64_t expr_idx,
6237
ObLLVMValue &p_result_obj)
6241
* 为防止计算溢出，用int64进行计算
6243
#define GET_LLVM_VALUE(expr, value) \
6245
if (OB_SUCC(ret)) { \6246
int64_t int_value = static_cast<const ObConstRawExpr*>(expr)->get_value().get_unknown(); \
6247
if (T_QUESTIONMARK == expr->get_expr_type()) { \6248
if (OB_FAIL(extract_value_from_context(vars_.at(CTX_IDX), int_value, ObIntType, value))) { \6249
LOG_WARN("failed to extract_value_from_context", K(ret)); \6251
} else if (expr->is_const_raw_expr()) { \6252
if (OB_FAIL(helper_.get_int64(int_value, value))) { \6253
LOG_WARN("failed to get int64", K(ret)); \6256
ret = OB_INVALID_ARGUMENT; \
6257
LOG_WARN("invalid expr type", K(*expr), K(ret)); \6262
int ret = OB_SUCCESS;
6263
const ObRawExpr *expr = ast_.get_expr(expr_idx);
6264
int64_t udt_id = expr->get_result_type().get_udt_id();
6265
if (OB_ISNULL(expr)) {6266
ret = OB_ERR_UNEXPECTED;
6267
LOG_WARN("expr is NULL", K(ret));6268
} else if (OB_FAIL(generate_new_objparam(p_result_obj, udt_id))) {6269
LOG_WARN("failed to generate_new_objparam", K(ret));6270
} else if (expr->is_const_raw_expr()) {6271
const ObObj &const_value = static_cast<const ObConstRawExpr*>(expr)->get_value();
6272
if (!const_value.is_int32()) {6273
ret = OB_ERR_UNEXPECTED;
6274
LOG_WARN("Invalid simple integer", K(const_value), K(ret));6276
if (OB_FAIL(generate_const_calc(const_value.get_int32(), p_result_obj))) {6277
LOG_WARN("failed to generate const calc", K(const_value), K(ret));6280
OZ (generate_debug(ObString("generate_llvm_calc result"), p_result_obj));6284
if (OB_ISNULL(expr->get_param_expr(0)) || OB_ISNULL(expr->get_param_expr(1))) {6285
ret = OB_ERR_UNEXPECTED;
6286
LOG_WARN("child expr is NULL", K(expr->get_param_expr(0)), K(expr->get_param_expr(1)), K(ret));6287
} else if (!expr->get_param_expr(0)->get_result_type().is_int32() || !expr->get_param_expr(1)->get_result_type().is_int32()) {6288
ret = OB_ERR_UNEXPECTED;
6289
LOG_WARN("Unexpected integer type", K(*expr->get_param_expr(0)), K(*expr->get_param_expr(1)), K(ret));6291
const ObRawExpr *left_expr = expr->get_param_expr(0);
6292
const ObRawExpr *right_expr = expr->get_param_expr(1);
6296
GET_LLVM_VALUE(left_expr, left);
6298
GET_LLVM_VALUE(right_expr, right);
6301
if (IS_COMMON_COMPARISON_OP(expr->get_expr_type())) {6302
if (OB_FAIL(generate_compare_calc(left, right, expr->get_expr_type(), p_result_obj))) {6303
LOG_WARN("failed to generate_new_objparam", K(ret));6306
if (OB_FAIL(generate_arith_calc(left, right, expr->get_expr_type(), expr->get_result_type(), stmt_id, in_notfound, in_warning, p_result_obj))) {6307
LOG_WARN("failed to generate_new_objparam", K(ret));6314
//存储进全局符号表和paramstore
6315
if (OB_SUCC(ret) && OB_INVALID_INDEX != result_idx) {6316
ObLLVMValue p_objparam;
6318
ObLLVMValue objparam;
6319
if (OB_FAIL(extract_datum_from_objparam(p_result_obj, ObInt32Type, obj))) {6320
LOG_WARN("failed to extract_datum_from_objparam", K(ret));6321
} else if (OB_FAIL(helper_.create_store(obj, vars_.at(result_idx + USER_ARG_OFFSET)))) {6322
LOG_WARN("failed to create_store", K(ret));6323
} else if (OB_FAIL(helper_.create_load("load_out_arg", p_result_obj, objparam))) {6324
LOG_WARN("failed to create_load", K(ret));6325
} else if (OB_FAIL(extract_objparam_from_context(vars_.at(CTX_IDX), result_idx, p_objparam))) {6326
LOG_WARN("failed to extract_datum_from_objparam", K(ret));6327
} else if (OB_FAIL(helper_.create_store(objparam, p_objparam))) {6328
LOG_WARN("failed to create_store", K(ret));6329
} else { /*do nothing*/ }6334
int ObPLCodeGenerator::generate_const_calc(int32_t value, ObLLVMValue &p_result_obj)
6336
int ret = OB_SUCCESS;
6337
ObLLVMValue p_value;
6338
ObLLVMValue calc_result;
6339
ObObjParam objparam;
6340
objparam.set_type(ObInt32Type);
6341
objparam.set_param_meta();
6342
if (OB_FAIL(store_objparam(objparam, p_result_obj))) {6343
LOG_WARN("Not supported yet", K(ret));6344
} else if (OB_FAIL(extract_value_ptr_from_objparam(p_result_obj, ObInt32Type, p_value))) {6345
LOG_WARN("failed to extract_value_ptr_from_objparam", K(ret));6346
} else if (OB_FAIL(helper_.get_int32(value, calc_result))) {6347
LOG_WARN("failed to extract_value_ptr_from_objparam", K(ret));6348
} else if (OB_FAIL(helper_.create_store(calc_result, p_value))) {6349
LOG_WARN("failed to create store", K(ret));6350
} else { /*do nothing*/ }6354
int ObPLCodeGenerator::generate_compare_calc(ObLLVMValue &left,
6357
ObLLVMValue &p_result_obj)
6359
int ret = OB_SUCCESS;
6360
ObLLVMHelper::CMPTYPE compare_type = ObLLVMHelper::ICMP_EQ;
6363
compare_type = ObLLVMHelper::ICMP_EQ;
6367
ret = OB_NOT_SUPPORTED;
6368
LOG_WARN("T_OP_NSEQ is not supported", K(type), K(ret));6369
LOG_USER_ERROR(OB_NOT_SUPPORTED, "null safe equals operator");
6373
compare_type = ObLLVMHelper::ICMP_SLE;
6377
compare_type = ObLLVMHelper::ICMP_SLT;
6381
compare_type = ObLLVMHelper::ICMP_SGE;
6385
compare_type = ObLLVMHelper::ICMP_SGT;
6389
compare_type = ObLLVMHelper::ICMP_NE;
6393
ret = OB_ERR_UNEXPECTED;
6394
LOG_WARN("Unexpected expr type", K(type), K(ret));6400
ObLLVMValue is_true;
6401
ObLLVMBasicBlock true_branch;
6402
ObLLVMBasicBlock false_branch;
6403
ObLLVMBasicBlock end_branch;
6406
OZ (generate_debug(ObString("debug"), left));6407
OZ (generate_debug(ObString("debug"), right));6409
if (OB_FAIL(helper_.create_block(ObString("true_branch"), get_func(), true_branch))) {6410
LOG_WARN("failed to create block", K(ret));6411
} else if (OB_FAIL(helper_.create_block(ObString("false_branch"), get_func(), false_branch))) {6412
LOG_WARN("failed to create block", K(ret));6413
} else if (OB_FAIL(helper_.create_block(ObString("end_branch"), get_func(), end_branch))) {6414
LOG_WARN("failed to create block", K(ret));6415
} else if (OB_FAIL(helper_.create_icmp(left, right, compare_type, is_true))) { //这里的is_true是int1(1 bit)，需要转成int8(8 bit)6416
LOG_WARN("failed to create_icmp_eq", K(ret));6417
} else if (OB_FAIL(helper_.create_cond_br(is_true, true_branch, false_branch))) {6418
LOG_WARN("failed to create_cond_br", K(ret));6419
} else { /*do nothing*/ }6422
ObObjParam objparam;
6423
objparam.set_tinyint(1);
6424
objparam.set_param_meta();
6425
if (OB_FAIL(helper_.set_insert_point(true_branch))) { \6426
LOG_WARN("failed to set insert point", K(ret)); \6427
} else if (OB_FAIL(store_objparam(objparam, p_result_obj))) {6428
LOG_WARN("failed to store objparam", K(ret));6429
} else if (OB_FAIL(helper_.create_br(end_branch))) {6430
LOG_WARN("failed to create_br", K(ret));6431
} else { /*do nothing*/ }6435
ObObjParam objparam;
6436
objparam.set_tinyint(0);
6437
objparam.set_param_meta();
6438
if (OB_FAIL(helper_.set_insert_point(false_branch))) { \6439
LOG_WARN("failed to set insert point", K(ret)); \6440
} else if (OB_FAIL(store_objparam(objparam, p_result_obj))) {6441
LOG_WARN("failed to store objparam", K(ret));6442
} else if (OB_FAIL(helper_.create_br(end_branch))) {6443
LOG_WARN("failed to create_br", K(ret));6444
} else { /*do nothing*/ }6447
if (OB_SUCC(ret) && OB_FAIL(set_current(end_branch))) {6448
LOG_WARN("failed to set_current", K(ret));6454
int ObPLCodeGenerator::generate_arith_calc(ObLLVMValue &left,
6457
const ObExprResType &result_type,
6461
ObLLVMValue &p_result_obj)
6463
int ret = OB_SUCCESS;
6464
ObLLVMValue p_value;
6465
ObLLVMValue calc_result;
6466
if (T_OP_ADD == type) {6467
if (OB_FAIL(helper_.create_add(left, right, calc_result))) {6468
LOG_WARN("failed to create_add", K(ret));6470
} else if (T_OP_MINUS == type) {6471
if (OB_FAIL(helper_.create_sub(left, right, calc_result))) {6472
LOG_WARN("failed to create_add", K(ret));6475
ret = OB_ERR_UNEXPECTED;
6476
LOG_WARN("Not supported yet", K(type), K(ret));6479
if (OB_SUCC(ret)) { //检查值域6480
ObLLVMBasicBlock succ_block;
6481
ObLLVMBasicBlock error_block;
6482
ObLLVMBasicBlock check_block;
6483
ObLLVMBasicBlock end_block;
6487
ObLLVMValue is_true;
6488
ObLLVMValue ret_value;
6489
ObLLVMValue ret_value_ptr;
6491
OZ (helper_.create_ialloca(ObString("ret_value"), ObInt32Type, OB_SUCCESS, ret_value_ptr));6492
OZ (helper_.create_block(ObString("succ_block"), func_, succ_block));6493
OZ (helper_.create_block(ObString("error_block"), func_, error_block));6494
OZ (helper_.create_block(ObString("check_block"), func_, check_block));6495
OZ (helper_.create_block(ObString("end_block"), func_, end_block));6496
OZ (helper_.get_int64(INT32_MIN, low));
6497
OZ (helper_.create_icmp(calc_result, low, ObLLVMHelper::ICMP_SGE, is_true));
6498
OZ (helper_.create_cond_br(is_true, check_block, error_block));
6499
OZ (helper_.set_insert_point(check_block));
6500
OZ (helper_.get_int64(INT32_MAX, high));
6501
OZ (helper_.create_icmp(high, calc_result, ObLLVMHelper::ICMP_SGE, is_true));
6502
OZ (helper_.create_cond_br(is_true, succ_block, error_block));
6503
OZ (helper_.set_insert_point(error_block));
6504
OZ (helper_.get_int32(OB_NUMERIC_OVERFLOW, ret_value));
6505
OZ (helper_.create_store(ret_value, ret_value_ptr));
6506
OZ (helper_.create_br(end_block));
6507
OZ (helper_.set_insert_point(succ_block));
6508
OZ (helper_.get_int32(OB_SUCCESS, ret_value));
6509
OZ (helper_.create_store(ret_value, ret_value_ptr));
6510
OZ (helper_.create_br(end_block));
6511
OZ (set_current(end_block));
6512
OZ (helper_.create_load(ObString("load_ret"), ret_value_ptr, ret_value));6513
OZ (check_success(ret_value, stmt_id, in_notfound, in_warning));
6517
ObObjParam objparam;
6518
objparam.set_type(result_type.get_type()); //计算之后的结果放在int32里
6519
objparam.set_param_meta();
6520
if (OB_FAIL(store_objparam(objparam, p_result_obj))) {6521
LOG_WARN("Not supported yet", K(type), K(ret));6522
} else if (OB_FAIL(extract_value_ptr_from_objparam(p_result_obj, ObIntType, p_value))) {6523
LOG_WARN("failed to extract_value_ptr_from_objparam", K(ret));6524
} else if (OB_FAIL(helper_.create_store(calc_result, p_value))) {6525
LOG_WARN("failed to create store", K(ret));6526
} else { /*do nothing*/ }6531
int ObPLCodeGenerator::generate_expr(int64_t expr_idx,
6534
ObLLVMValue &p_result_obj)
6536
int ret = OB_SUCCESS;
6537
ObLLVMValue expr_addr;
6538
if (OB_INVALID_INDEX == expr_idx || OB_ISNULL(s.get_block())) {6539
ret = OB_ERR_UNEXPECTED;
6540
LOG_WARN("Unexpected argument", K(expr_idx), K(s.get_block()), K(ret));6541
} else if (lib::is_oracle_mode() && ast_.is_simple_calc(expr_idx)) {6542
if (OB_FAIL(generate_llvm_calc(expr_idx,
6544
s.get_block()->in_notfound(),
6545
s.get_block()->in_warning(),
6546
result_idx, p_result_obj))) {6547
LOG_WARN("failed to create_store", K(ret));6550
if (OB_FAIL(generate_spi_calc(expr_idx,
6552
s.get_block()->in_notfound(),
6553
s.get_block()->in_warning(),
6556
LOG_WARN("failed to create_store", K(ret));6562
int ObPLCodeGenerator::generate_early_exit(ObLLVMValue &count,
6567
int ret = OB_SUCCESS;
6568
ObLLVMBasicBlock early_exit;
6569
ObLLVMBasicBlock after_check;
6570
ObLLVMValue is_true, need_check, first_check;
6571
ObSEArray<ObLLVMValue, 4> args;
6573
ObLLVMValue count_value;
6575
OZ (helper_.create_block(ObString("early_exit"), get_func(), early_exit));6576
OZ (helper_.create_block(ObString("after_check"), get_func(), after_check));6578
OZ (helper_.create_load(ObString("load_count"), count, count_value));6579
OZ (helper_.create_inc(count_value, count_value));
6580
OZ (helper_.create_store(count_value, count));
6582
OZ (generate_debug(ObString("print count value"), count_value));6585
* need_check和first_check不等说明需要check, 相等则不需要check
6586
* 因为need_check和firstcheck不可能同时为true; 当同时为false时说明两个条件都没满足; 只有一个true时则说明满足一个条件;
6587
* 引入first_check是为了避免类似下面的匿名块形成的死循环无法退出;
6590
* FOR idx IN 1..10 LOOP
6591
* CONTINUE outer_loop;
6595
OZ (helper_.create_icmp(count_value, EARLY_EXIT_CHECK_CNT, ObLLVMHelper::ICMP_SGE, need_check)); // 到达check次数
6596
OZ (helper_.create_icmp(count_value, 1, ObLLVMHelper::ICMP_EQ, first_check)); // 该值为1说明是循环的第一次check
6597
OZ (helper_.create_icmp(need_check, first_check, ObLLVMHelper::ICMP_NE, is_true));
6598
OZ (helper_.create_cond_br(is_true, early_exit, after_check));
6600
//处理check early exit
6601
OZ (set_current(early_exit));
6602
OZ (helper_.create_istore(1, count));
6603
OZ (args.push_back(get_vars().at(CTX_IDX)));
6604
OZ (helper_.create_call(ObString("check_early_exit"), get_spi_service().spi_check_early_exit_, args, result));6605
OZ (check_success(result, stmt_id, in_notfound, in_warning));
6606
OZ (helper_.create_br(after_check));
6609
OZ (set_current(after_check));
6614
int ObPLCodeGenerator::generate_pointer(const void *ptr, ObLLVMValue &value)
6616
int ret = OB_SUCCESS;
6617
int64_t addr = reinterpret_cast<int64_t>(ptr);
6618
if (OB_FAIL(helper_.get_int64(addr, value))) {6619
LOG_WARN("failed to get int64", K(ret));6624
int ObPLCodeGenerator::generate_expression_array(const ObIArray<int64_t> &exprs,
6625
jit::ObLLVMValue &value,
6626
jit::ObLLVMValue &count)
6628
int ret = OB_SUCCESS;
6629
ObSEArray<uint64_t, 8> expr_addrs;
6630
for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {6631
if (OB_FAIL(expr_addrs.push_back(reinterpret_cast<uint64_t>(get_expr(exprs.at(i)))))) {6632
LOG_WARN("store expr addr failed", K(ret));6636
ObLLVMValue first_addr;
6637
if (expr_addrs.empty()) {6638
if (OB_FAIL(generate_null_pointer(ObIntType, value))) {6639
LOG_WARN("failed to generate_null_pointer", K(ret));6642
if (OB_FAIL(generate_uint64_array(expr_addrs, value))) {6643
LOG_WARN("failed to get_uint64_array", K(ret));6647
ObLLVMValue int_value;
6648
if (OB_FAIL(helper_.get_int64(exprs.count(), count))) {6649
LOG_WARN("failed to get int64", K(ret));6656
#define CHECK_COND_CONTROL \
6658
if (OB_SUCC(ret)) { \6659
ObLLVMBasicBlock do_control; \
6660
if (OB_INVALID_INDEX != control.get_cond()) { \6661
ObLLVMValue p_result_obj; \
6662
ObLLVMValue result; \
6663
ObLLVMValue is_false; \
6664
if (OB_FAIL(helper_.create_block(ObString("do_control"), get_func(), do_control))) { \6665
LOG_WARN("failed to create block", K(ret)); \6666
} else if (OB_FAIL(helper_.create_block(ObString("after_control"), get_func(), after_control))) { \6667
LOG_WARN("failed to create block", K(ret)); \6668
} else if (OB_FAIL(generate_expr(control.get_cond(), control, OB_INVALID_INDEX, p_result_obj))) { \6669
LOG_WARN("failed to generate calc_expr func", K(ret)); \6670
} else if (OB_FAIL(extract_value_from_objparam(p_result_obj, control.get_cond_expr()->get_data_type(), result))) { \6671
LOG_WARN("failed to extract_value_from_objparam", K(ret)); \6672
} else if (OB_FAIL(helper_.create_icmp_eq(result, FALSE, is_false))) { \6673
LOG_WARN("failed to create_icmp_eq", K(ret)); \6674
} else if (OB_FAIL(helper_.create_cond_br(is_false, after_control, do_control))) { \6675
LOG_WARN("failed to create_cond_br", K(ret)); \6676
} else if (OB_FAIL(set_current(do_control))) { \6677
LOG_WARN("failed to set insert point", K(ret)); \6680
if (OB_FAIL(helper_.create_block(ObString("do_control"), get_func(), do_control))) { \6681
LOG_WARN("failed to create block", K(ret)); \6682
} else if (OB_FAIL(helper_.create_block(ObString("after_control"), get_func(), after_control))) { \6683
LOG_WARN("failed to create block", K(ret)); \6684
} else if (OB_FAIL(helper_.create_br(do_control))) { \6685
LOG_WARN("failed to create_cond_br", K(ret)); \6686
} else if (OB_FAIL(set_current(do_control))) { \6687
LOG_WARN("failed to set insert point", K(ret)); \6693
//跳转目的地和跳转语句之间的所有循环的栈都需要重置
6694
#define RESTORE_LOOP_STACK \
6696
if (OB_SUCC(ret)) { \6697
const ObPLCodeGenerator::LabelStack::LabelInfo *label_info = get_label(control.get_next_label()); \
6698
if (OB_ISNULL(label_info)) { \6699
ret = OB_ERR_LABEL_ILLEGAL; \
6700
LOG_WARN("label info is NULL", K(control.get_next_label()), K(ret)); \6701
LOG_USER_ERROR(OB_ERR_LABEL_ILLEGAL, control.get_next_label().length(), \
6702
control.get_next_label().ptr()); \
6704
LOG_DEBUG("label info is not null", K(control.get_next_label()), K(label_info->name_), K(label_info->level_)); \6705
for (int64_t i = get_loop_count() - 1; OB_SUCC(ret) && i >= 0; --i) { \6706
ObPLCodeGenerator::LoopStack::LoopInfo &loop_info = get_loops()[i]; \
6707
LOG_DEBUG("loop info", K(i), K(loop_info.level_), K(control.get_level())); \6708
if (loop_info.level_ <= control.get_level() && loop_info.level_ >= label_info->level_) { \6709
if (OB_NOT_NULL(loop_info.cursor_) \
6710
&& loop_info.level_ != label_info->level_ \
6711
&& OB_FAIL(generate_close(*loop_info.cursor_, \
6712
loop_info.cursor_->get_cursor()->get_package_id(), \
6713
loop_info.cursor_->get_cursor()->get_routine_id(), \
6714
loop_info.cursor_->get_index(), \
6717
LOG_WARN("failed to generate close for loop cursor", K(ret)); \6718
} else if (OB_FAIL(helper_.stack_restore(loop_info.loop_))) { \6719
LOG_WARN("failed to stack_restore", K(ret)); \6721
LOG_DEBUG("success stack restore", K(i), K(loop_info.level_)); \6729
int ObPLCodeGenerator::generate_loop_control(const ObPLLoopControl &control)
6731
int ret = OB_SUCCESS;
6732
if (NULL == get_current().get_v()) {6734
} else if (OB_FAIL(helper_.set_insert_point(get_current()))) {6735
LOG_WARN("failed to set insert point", K(ret));6736
} else if (OB_FAIL(set_debug_location(control))) {6737
LOG_WARN("failed to set debug location", K(ret));6738
} else if (OB_FAIL(generate_goto_label(control))) {6739
LOG_WARN("failed to generate goto label", K(ret));6740
} else if (!control.get_next_label().empty()) {6741
ObLLVMBasicBlock after_control;
6748
ObLLVMBasicBlock next = PL_LEAVE == control.get_type() ? get_label(control.get_next_label())->exit_ : get_label(control.get_next_label())->start_;
6749
if (OB_ISNULL(next.get_v())) {6750
ret = OB_ERR_UNEXPECTED;
6751
LOG_WARN("a loop must have valid body", K(next), K(ret));6752
} else if (OB_FAIL(helper_.create_br(next))) {6753
LOG_WARN("failed to create br", K(ret));6755
if (OB_FAIL(set_current(after_control))) { //设置CURRENT, 调整INSERT POINT点6756
LOG_WARN("failed to set current", K(ret));6761
ObLLVMBasicBlock after_control;
6766
ObPLCodeGenerator::LoopStack::LoopInfo *loop_info = get_current_loop();
6767
if (OB_ISNULL(loop_info)) {6768
ret = OB_ERR_EXIT_CONTINUE_ILLEGAL;
6769
LOG_WARN("illegal EXIT/CONTINUE statement; it must appear inside a loop", K(ret));6770
} else if (OB_FAIL(helper_.stack_restore(loop_info->loop_))) {6771
LOG_WARN("failed to stack_restore", K(ret));6773
ObLLVMBasicBlock next = PL_LEAVE == control.get_type() ? loop_info->exit_ : loop_info->start_;
6774
if (OB_ISNULL(next.get_v())) {6775
ret = OB_ERR_UNEXPECTED;
6776
LOG_WARN("a loop must have valid body", K(ret));6777
} else if (OB_FAIL(helper_.create_br(next))) {6778
LOG_WARN("failed to create br", K(ret));6780
if (OB_FAIL(set_current(after_control))) { //设置CURRENT, 调整INSERT POINT点6781
LOG_WARN("failed to set current", K(ret));6790
int ObPLCodeGenerator::generate_sql(const ObPLSql &sql,
6791
jit::ObLLVMValue &str,
6792
jit::ObLLVMValue &length,
6793
jit::ObLLVMValue &ps_sql,
6794
jit::ObLLVMValue &type,
6795
jit::ObLLVMValue &for_update,
6796
jit::ObLLVMValue &hidden_rowid,
6797
jit::ObLLVMValue ¶ms,
6798
jit::ObLLVMValue &count,
6799
jit::ObLLVMValue &skip_locked)
6801
int ret = OB_SUCCESS;
6802
ObLLVMValue int_value;
6803
if (sql.get_params().empty()) {6804
if (OB_FAIL(generate_global_string(sql.get_sql(), str, length))) {6805
LOG_WARN("failed to get_string", K(ret));6808
if (OB_FAIL(generate_null(ObCharType, str))) {6809
LOG_WARN("failed to get_null_const", K(ret));6814
if (OB_FAIL(generate_global_string(sql.get_ps_sql(), ps_sql, length))) {6815
LOG_WARN("failed to get_string", K(ret));6816
} else if (OB_FAIL(helper_.get_int64(sql.get_stmt_type(), type))) {6817
LOG_WARN("failed to get int64", K(ret));6818
} else if (OB_FAIL(helper_.get_int8(sql.is_for_update(), for_update))) {6819
LOG_WARN("failed to get int8", K(ret));6820
} else if (OB_FAIL(helper_.get_int8(sql.has_hidden_rowid(), hidden_rowid))) {6821
LOG_WARN("failed to get int8", K(ret));6822
} else if (OB_FAIL(generate_expression_array(
6823
sql.is_forall_sql() ? sql.get_array_binding_params() : sql.get_params(), params, count))) {6824
LOG_WARN("get precalc expr array ir value failed", K(ret));6825
} else if (OB_FAIL(helper_.get_int8(sql.is_skip_locked(), skip_locked))) {6826
LOG_WARN("failed to get int8", K(ret));6827
} else { /*do nothing*/ }6832
int ObPLCodeGenerator::generate_into(const ObPLInto &into,
6833
ObLLVMValue &into_array_value,
6834
ObLLVMValue &into_count_value,
6835
ObLLVMValue &type_array_value,
6836
ObLLVMValue &type_count_value,
6837
ObLLVMValue &exprs_not_null_array_value,
6838
ObLLVMValue &pl_integer_range_array_value,
6839
ObLLVMValue &is_bulk)
6841
int ret = OB_SUCCESS;
6842
if (OB_FAIL(generate_expression_array(into.get_into(), into_array_value, into_count_value))) {6843
LOG_WARN("Failed to generate_into", K(ret));6844
} else if (OB_FAIL(helper_.get_int8(static_cast<int64_t>(into.is_bulk()), is_bulk))) {6845
LOG_WARN("failed to get int8", K(ret));6846
} else if (into.get_data_type().count() != into.get_not_null_flags().count()
6847
|| into.get_data_type().count() != into.get_pl_integer_ranges().count()) {6848
ret = OB_ERR_UNEXPECTED;
6849
LOG_WARN("not null flags count is inconsistent with data type count.",6851
K(into.get_data_type()),
6852
K(into.get_not_null_flags()),
6853
K(into.get_pl_integer_ranges()));
6854
} else if (into.is_type_record() && 1 != into.get_into_data_type().count()) {6855
ret = OB_ERR_EXPRESSION_WRONG_TYPE;
6856
LOG_WARN("coercion into multiple record targets not supported", K(ret));6858
ObLLVMType data_type;
6859
ObLLVMType data_type_pointer;
6860
ObLLVMType array_type;
6861
ObLLVMType bool_type;
6862
ObLLVMType not_null_pointer;
6863
ObLLVMType nn_array_type; //not null array
6864
ObLLVMType int64_type;
6865
ObLLVMType range_range_pointer;
6866
ObLLVMType range_range_type;
6867
OZ (adt_service_.get_data_type(data_type));
6868
OZ (data_type.get_pointer_to(data_type_pointer));
6869
OZ (ObLLVMHelper::get_array_type(data_type,
6870
into.get_data_type().count(),
6872
OZ (helper_.create_alloca(ObString("datatype_array"),6876
OZ (helper_.get_llvm_type(ObTinyIntType, bool_type));
6877
OZ (bool_type.get_pointer_to(not_null_pointer));
6878
OZ (ObLLVMHelper::get_array_type(bool_type,
6879
into.get_data_type().count(),
6881
OZ (helper_.create_alloca(ObString("not_null_array"),6883
exprs_not_null_array_value));
6885
OZ (helper_.get_llvm_type(ObIntType, int64_type));
6886
OZ (int64_type.get_pointer_to(range_range_pointer));
6887
OZ (ObLLVMHelper::get_array_type(int64_type,
6888
into.get_data_type().count(),
6890
OZ (helper_.create_alloca(ObString("range_array"),6892
pl_integer_range_array_value));
6894
ObLLVMValue type_value;
6895
ObLLVMValue nnv_dest; // nnv is short for not null value
6896
ObLLVMValue nnv_src;
6897
ObLLVMValue src_not_null_value;
6898
ObLLVMValue range_dest;
6899
ObLLVMValue range_src;
6901
for (int64_t i = 0; OB_SUCC(ret) && i < into.get_data_type().count(); ++i) {6904
OZ (helper_.create_gep(ObString("extract_datatype"), type_array_value, i, type_value));6905
OZ (store_data_type(into.get_data_type(i), type_value));
6907
OZ (helper_.create_gep(ObString("extract_not_null"),6908
exprs_not_null_array_value, i, nnv_dest));
6909
OZ (helper_.get_int8(static_cast<int64_t>(into.get_not_null_flag(i)), nnv_src));
6910
OZ (helper_.create_store(nnv_src, nnv_dest));
6912
OZ (helper_.create_gep(ObString("extract_range"),6913
pl_integer_range_array_value, i, range_dest));
6914
OZ (helper_.get_int64(into.get_pl_integer_range(i), range_src));
6915
OZ (helper_.create_store(range_src, range_dest));
6918
OZ (helper_.create_bit_cast(ObString("datatype_array_to_pointer"),6919
type_array_value, data_type_pointer, type_array_value));
6920
OZ (helper_.create_bit_cast(ObString("not_null_array_to_pointer"),6921
exprs_not_null_array_value, not_null_pointer, exprs_not_null_array_value));
6922
OZ (helper_.create_bit_cast(ObString("range_array_to_pointer"),6923
pl_integer_range_array_value, range_range_pointer, pl_integer_range_array_value));
6924
OZ (helper_.get_int64(static_cast<int64_t>(into.get_data_type().count()), type_count_value));
6930
int ObPLCodeGenerator::generate_into_restore(const ObIArray<int64_t> &into,
6931
const common::ObIArray<ObRawExpr*> *exprs,
6932
const ObPLSymbolTable *symbol_table)
6934
int ret = OB_SUCCESS;
6935
if (OB_ISNULL(exprs) || OB_ISNULL(symbol_table)) {6936
ret = OB_ERR_UNEXPECTED;
6937
LOG_WARN("symbol_table is NULL", K(exprs), K(symbol_table), K(ret));6939
for (int64_t i = 0; OB_SUCC(ret) && i < into.count(); ++i) {6940
const ObRawExpr *into_expr = NULL;
6941
if (into.at(i) < 0 || into.at(i) >= exprs->count() || OB_ISNULL(into_expr = exprs->at(into.at(i)))) {6942
ret = OB_ERR_UNEXPECTED;
6943
LOG_WARN("into expr is NULL", K(i), K(into.at(i)), K(exprs->count()), K(into_expr), K(ret));6944
} else if (into_expr->is_const_raw_expr() && !into_expr->get_result_type().is_ext()) {6945
//只有值传递的变量（Local 基本变量）需要回存进全局符号表
6946
if (!static_cast<const ObConstRawExpr*>(into_expr)->get_value().is_unknown()) {6947
ret = OB_ERR_UNEXPECTED;
6948
LOG_WARN("Invalid into expr", K(static_cast<const ObConstRawExpr*>(into_expr)->get_value()), K(ret));6950
int64_t idx = static_cast<const ObConstRawExpr*>(into_expr)->get_value().get_unknown();
6951
const ObPLVar* var = symbol_table->get_symbol(idx);
6952
if (OB_ISNULL(var)) {6953
ret = OB_ERR_UNEXPECTED;
6954
LOG_WARN("var is NULL", K(i), K(idx), K(var), K(ret));6957
if (OB_FAIL(extract_datum_from_context(vars_.at(CTX_IDX), idx, var->get_type().get_obj_type(), result))) {6958
LOG_WARN("failed to extract_value_from_context", K(ret));6959
} else if (var->get_type().is_composite_type()) {6961
ObLLVMType ir_popinter_type;
6962
if (OB_FAIL(get_llvm_type(var->get_type(), ir_type))) {6963
LOG_WARN("get pl ir type failed", K(ret));6964
} else if (OB_FAIL(ir_type.get_pointer_to(ir_popinter_type))) {6965
LOG_WARN("failed to get pointer", K(ret));6966
} else if (OB_FAIL(helper_.create_int_to_ptr(ObString("cast_int_to_ptr"), result, ir_popinter_type, result))) {6967
LOG_WARN("failed to create_int_to_ptr", K(ret));6968
} else if (OB_FAIL(helper_.create_load(ObString("load_var"), result, result))) {6969
LOG_WARN("failed to create_load", K(ret));6970
} else { /*do nothing*/ }6971
} else { /*do nothing*/ }6973
if (OB_SUCC(ret) && OB_FAIL(helper_.create_store(result, vars_.at(idx + USER_ARG_OFFSET)))) {6974
LOG_WARN("failed to create_store", K(ret));6978
} else { /*do nothing*/ }6984
int ObPLCodeGenerator::generate_set_variable(int64_t expr,
6991
int ret = OB_SUCCESS;
6992
ObSEArray<ObLLVMValue, 5> args;
6993
ObLLVMValue expr_addr;
6994
ObLLVMValue is_default_value, need_copy;
6996
if (OB_FAIL(args.push_back(get_vars().at(CTX_IDX)))) { //PL的执行环境6997
LOG_WARN("push_back error", K(ret));6998
} else if (OB_FAIL(generate_pointer(get_expr(expr), expr_addr))) {6999
LOG_WARN("failed to generate a pointer", K(ret));7000
} else if (OB_FAIL(args.push_back(expr_addr))) { //expr7001
LOG_WARN("push_back error", K(ret));7002
} else if (OB_FAIL(args.push_back(value))) { //value7003
LOG_WARN("push_back error", K(ret));7004
} else if (OB_FAIL(helper_.get_int8(is_default, is_default_value))) {7005
LOG_WARN("failed tio get int8", K(is_default), K(ret));7006
} else if (OB_FAIL(args.push_back(is_default_value))) { //is_default7007
LOG_WARN("push_back error", K(ret));7008
} else if (OB_FAIL(helper_.get_int8(false, need_copy))) {7009
LOG_WARN("failed tio get int8", K(ret));7010
} else if (OB_FAIL(args.push_back(need_copy))) {7011
LOG_WARN("push_back error", K(ret));7012
} else if (OB_FAIL(get_helper().create_call(ObString("spi_set_variable"), get_spi_service().spi_set_variable_, args, result))) {7013
LOG_WARN("failed to create call", K(ret));7014
} else if (OB_FAIL(check_success(result, stmt_id, in_notfound, in_warning))) {7015
LOG_WARN("failed to check success", K(ret));7016
} else { /*do nothing*/ }7020
int ObPLCodeGenerator::generate_update_package_changed_info(const ObPLStmt &s,
7021
uint64_t package_id,
7024
int ret = OB_SUCCESS;
7025
ObSEArray<ObLLVMValue, 3> args;
7026
ObLLVMValue package_id_value;
7027
ObLLVMValue var_idx_value;
7029
OZ (args.push_back(get_vars().at(CTX_IDX)));
7030
OZ (helper_.get_int64(package_id, package_id_value));
7031
OZ (args.push_back(package_id_value));
7032
OZ (helper_.get_int64(var_idx, var_idx_value));
7033
OZ (args.push_back(var_idx_value));
7034
OZ (get_helper().create_call(ObString("spi_update_package_change_info"),7035
get_spi_service().spi_update_package_change_info_,
7038
result, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
7042
int ObPLCodeGenerator::generate_exception(ObLLVMValue &type,
7043
ObLLVMValue &ob_error_code,
7044
ObLLVMValue &error_code,
7045
ObLLVMValue &sql_state,
7046
ObLLVMValue &str_len,
7047
ObLLVMValue &stmt_id,
7048
ObLLVMBasicBlock &normal,
7049
ObLLVMValue &line_number,
7054
int ret = OB_SUCCESS;
7055
if (OB_FAIL(helper_.set_insert_point(get_current()))) {7056
LOG_WARN("failed to set insert point", K(ret));7058
ObSEArray<ObLLVMValue, 2> args;
7061
if (OB_FAIL(extract_status_from_context(get_vars().at(CTX_IDX), status))) {7062
LOG_WARN("failed to extract_status_from_context", K(ret));7063
} else if (OB_FAIL(helper_.create_store(ob_error_code, status))) {7064
LOG_WARN("failed to create_store", K(ret));7065
} else if (OB_FAIL(extract_pl_ctx_from_context(get_vars().at(CTX_IDX), arg))) { //obplcontext7066
LOG_WARN("failed to set pl context", K(ret));7067
} else if (OB_FAIL(args.push_back(arg))) {7068
LOG_WARN("push_back error", K(ret));7069
} else if (OB_FAIL(extract_pl_function_from_context(get_vars().at(CTX_IDX), arg))) { //obplfunction7070
LOG_WARN("failed to set pl function", K(ret));7071
} else if (OB_FAIL(args.push_back(arg))) {7072
LOG_WARN("push_back error", K(ret));7073
} else if (OB_FAIL(args.push_back(line_number))) { // line number7074
LOG_WARN("push_back error", K(ret));7075
} else if (OB_FAIL(extract_allocator_from_context(get_vars().at(CTX_IDX), arg))) { //allocator7076
LOG_WARN("failed to set extract_allocator_from_context", K(ret));7077
} else if (OB_FAIL(args.push_back(arg))) {7078
LOG_WARN("push_back error", K(ret));7080
ObLLVMType condition_type;
7081
ObLLVMValue condition;
7082
ObLLVMValue type_pointer;
7083
ObLLVMValue error_code_pointer;
7084
ObLLVMValue sql_state_pointer;
7085
ObLLVMValue str_len_pointer;
7086
ObLLVMValue stmt_id_pointer;
7087
ObLLVMValue signal_pointer;
7088
ObLLVMValue int_value;
7089
if (OB_FAIL(adt_service_.get_pl_condition_value(condition_type))) {7090
LOG_WARN("failed to get_pl_condition_value", K(ret));7091
} else if (OB_FAIL(helper_.create_alloca(ObString("handler_condition"), condition_type, condition))) {7092
LOG_WARN("failed to create_alloca", K(ret));7093
} else if (OB_FAIL(extract_type_ptr_from_condition_value(condition, type_pointer))) {7094
LOG_WARN("failed to extract_type_ptr_from_condition_value", K(ret));7095
} else if (OB_FAIL(helper_.create_store(type, type_pointer))) {7096
LOG_WARN("failed to create_store", K(ret));7097
} else if (OB_FAIL(extract_code_ptr_from_condition_value(condition, error_code_pointer))) {7098
LOG_WARN("failed to extract_code_ptr_from_condition_value", K(ret));7099
} else if (OB_FAIL(helper_.create_store(error_code, error_code_pointer))) {7100
LOG_WARN("failed to create_store", K(ret));7101
} else if (OB_FAIL(extract_name_ptr_from_condition_value(condition, sql_state_pointer))) {7102
LOG_WARN("failed to extract_name_ptr_from_condition_value", K(ret));7103
} else if (OB_FAIL(helper_.create_store(sql_state, sql_state_pointer))) {7104
LOG_WARN("failed to create_store", K(ret));7105
} else if (OB_FAIL(extract_len_ptr_from_condition_value(condition, str_len_pointer))) {7106
LOG_WARN("failed to extract_len_ptr_from_condition_value", K(ret));7107
} else if (OB_FAIL(helper_.create_store(str_len, str_len_pointer))) {7108
LOG_WARN("failed to create_store", K(ret));7109
} else if (OB_FAIL(extract_stmt_ptr_from_condition_value(condition, stmt_id_pointer))) {7110
LOG_WARN("failed to extract_stmt_ptr_from_condition_value", K(ret));7111
} else if (OB_FAIL(helper_.create_store(stmt_id, stmt_id_pointer))) {7112
LOG_WARN("failed to create_store", K(ret));7113
} else if (OB_FAIL(extract_signal_ptr_from_condition_value(condition, signal_pointer))) {7114
LOG_WARN("failed to extract_signal_ptr_from_condition_value", K(ret));7115
} else if (OB_FAIL(helper_.get_int8(signal, int_value))) {7116
LOG_WARN("failed to get int8", K(ret));7117
} else if (OB_FAIL(helper_.create_store(int_value, signal_pointer))) {7118
LOG_WARN("failed to create_store", K(ret));7119
} else if (OB_FAIL(args.push_back(condition))) {7120
LOG_WARN("push_back error", K(ret));7122
} else if (OB_FAIL(helper_.get_int64(4444, int_value))) {7123
LOG_WARN("failed to get int64", K(ret));7124
} else if (OB_FAIL(generate_debug(ObString("debug"), int_value))) {7125
LOG_WARN("failed to create_call", K(ret));7128
ObLLVMValue exception;
7129
if (OB_FAIL(helper_.create_call(ObString("create_exception"), get_eh_service().eh_create_exception_, args, exception))) {7130
LOG_WARN("failed to create_call", K(ret));7132
OZ (raise_exception(exception, error_code, sql_state, normal, in_notfound, in_warning, signal));
7140
int ObPLCodeGenerator::generate_close_loop_cursor(bool is_from_exception, int64_t dest_level)
7142
int ret = OB_SUCCESS;
7143
for (int64_t i = get_loop_count() - 1; OB_SUCC(ret) && i >= 0; --i) {7144
LoopStack::LoopInfo &loop_info = get_loops()[i];
7145
if (loop_info.level_ >= dest_level && NULL != loop_info.cursor_) {7146
LOG_INFO("close ForLoop Cursor", KPC(loop_info.cursor_->get_cursor()), K(dest_level), K(is_from_exception), K(ret));7147
OZ (generate_close(*loop_info.cursor_,
7148
loop_info.cursor_->get_cursor()->get_package_id(),
7149
loop_info.cursor_->get_cursor()->get_routine_id(),
7150
loop_info.cursor_->get_index(),
7151
false,/*cannot ignoe as must have been opened*/
7152
!is_from_exception/*此时已经在exception里，如果出错不能再抛exception了*/));
7158
int ObPLCodeGenerator::raise_exception(ObLLVMValue &exception,
7159
ObLLVMValue &error_code,
7160
ObLLVMValue &sql_state,
7161
ObLLVMBasicBlock &normal,
7166
int ret = OB_SUCCESS;
7169
* 如果到了顶层handler，都没有捕捉到了该exception，视exception的类型决定下一个目的地：
7170
* SQLEXCEPTION：继续抛出异常
7171
* SQLWARNING：跳到抛出exception的语句的下一句
7172
* NOT FOUND：如果显式（raised by SIGNAL or RESIGNAL）抛出，继续抛出异常；如果是隐式抛出（raised normally），跳到抛出exception的语句的下一句
7177
ObLLVMBasicBlock current = get_current();
7178
ObLLVMBasicBlock raise_exception;
7179
OZ (helper_.create_block(ObString("raise_exception"), get_func(), raise_exception));7180
OZ (set_current(raise_exception));
7182
ObLLVMValue ret_value;
7183
ObLLVMValue exception_result;
7186
* 关闭从当前位置开始到目的exception位置所有For Loop Cursor
7187
* 因为此时已经在exception过程中，只尝试关闭，不再check_success
7189
OZ (generate_close_loop_cursor(true, get_current_exception() != NULL ? get_current_exception()->level_ : 0));
7190
if (OB_ISNULL(get_current_exception())) {7191
OZ (helper_.create_call(ObString("raise_exception"),7192
get_eh_service().eh_raise_exception_,
7195
#if defined(__aarch64__)
7196
// On ARM, _Unwind_RaiseException may failed.
7197
OZ (generate_debug(ObString("CALL: failed to raise exception!"), exception_result));7198
OZ (helper_.create_load(ObString("load_ret"), get_vars().at(RET_IDX), ret_value));7199
OZ (helper_.create_ret(ret_value));
7201
OZ (helper_.create_unreachable());
7204
OZ (helper_.create_invoke(ObString("raise_exception"),7205
get_eh_service().eh_raise_exception_,
7208
get_current_exception()->exception_,
7213
OZ (set_current(current));
7215
} else if (lib::is_oracle_mode()) {7216
OZ (helper_.create_br(raise_exception));
7217
} else if (lib::is_mysql_mode()) {7218
ObLLVMBasicBlock normal_raise_block;
7219
ObLLVMValue exception_class;
7220
ObLLVMSwitch switch_inst1;
7221
ObLLVMSwitch switch_inst2;
7222
ObLLVMValue int_value;
7224
OZ (helper_.create_block(ObString("normal_raise_block"), get_func(), normal_raise_block));7225
OZ (helper_.create_switch(error_code, normal_raise_block, switch_inst1));
7226
OZ (helper_.get_int64(ER_WARN_TOO_MANY_RECORDS, int_value));
7227
OZ (switch_inst1.add_case(int_value, raise_exception));
7228
OZ (helper_.get_int64(WARN_DATA_TRUNCATED, int_value));
7229
OZ (switch_inst1.add_case(int_value, raise_exception));
7230
OZ (helper_.get_int64(ER_SIGNAL_WARN, int_value));
7231
OZ (switch_inst1.add_case(int_value, raise_exception));
7233
OZ (set_current(normal_raise_block));
7234
OZ (helper_.create_call(ObString("get_exception_class"), get_eh_service().eh_classify_exception, sql_state, exception_class));7235
OZ (helper_.create_switch(exception_class, raise_exception, switch_inst2));
7236
OZ (helper_.get_int64(SQL_WARNING, int_value));
7237
OZ (switch_inst2.add_case(int_value, in_warning ? raise_exception : normal));
7238
OZ (helper_.get_int64(NOT_FOUND, int_value));
7239
OZ (switch_inst2.add_case(int_value, signal || in_notfound ? raise_exception : normal));
7244
int ObPLCodeGenerator::check_success(jit::ObLLVMValue &ret_err, int64_t stmt_id,
7245
bool in_notfound, bool in_warning, bool signal)
7247
int ret = OB_SUCCESS;
7248
if (OB_FAIL(helper_.set_insert_point(get_current()))) {7249
LOG_WARN("failed to set insert point", K(ret));7250
} else if (OB_FAIL(helper_.create_store(ret_err, vars_.at(RET_IDX)))) {7251
LOG_WARN("failed to create_store", K(ret));7253
ObLLVMBasicBlock success_branch;
7254
ObLLVMBasicBlock fail_branch;
7255
ObLLVMValue is_true;
7257
if (OB_FAIL(helper_.create_block(ObString("ob_success"), get_func(), success_branch))) {7258
LOG_WARN("failed to create block", K(ret));7259
} else if (OB_FAIL(helper_.create_block(ObString("ob_fail"), get_func(), fail_branch))) {7260
LOG_WARN("failed to create block", K(ret));7261
} else if (OB_FAIL(helper_.create_icmp_eq(ret_err, OB_SUCCESS, is_true))) {7262
LOG_WARN("failed to create_icmp_eq", K(ret));7263
} else if (OB_FAIL(helper_.create_cond_br(is_true, success_branch, fail_branch))) {7264
LOG_WARN("failed to create_cond_br", K(ret));7265
} else if (OB_FAIL(set_current(fail_branch))) {7266
LOG_WARN("failed to set_current", K(ret));7268
ObLLVMType int_type;
7269
ObLLVMType char_type;
7270
ObLLVMValue type_ptr;
7271
ObLLVMValue error_code_ptr;
7272
ObLLVMValue sql_state_ptr;
7273
ObLLVMValue str_len_ptr;
7274
if (OB_FAIL(helper_.get_llvm_type(ObIntType, int_type))) {7275
LOG_WARN("failed to get_llvm_type", K(ret));7276
} else if (OB_FAIL(helper_.get_llvm_type(ObCharType, char_type))) {7277
LOG_WARN("failed to get_llvm_type", K(ret));7278
} else if (OB_FAIL(helper_.create_alloca(ObString("exception_type"), int_type, type_ptr))) {7279
LOG_WARN("failed to create_alloca", K(ret));7280
} else if (OB_FAIL(helper_.create_alloca(ObString("error_code"), int_type, error_code_ptr))) {7281
LOG_WARN("failed to create_alloca", K(ret));7282
} else if (OB_FAIL(helper_.create_alloca(ObString("sql_state"), char_type, sql_state_ptr))) {7283
LOG_WARN("failed to create_alloca", K(ret));7284
} else if (OB_FAIL(helper_.create_alloca(ObString("str_len"), int_type, str_len_ptr))) {7285
LOG_WARN("failed to create_alloca", K(ret));7287
ObSEArray<ObLLVMValue, 2> args;
7288
ObLLVMValue oracle_mode;
7289
if (OB_FAIL(helper_.get_int8(oracle_mode_, oracle_mode))) {7290
LOG_WARN("helper get int8 failed", K(ret));7291
} else if (OB_FAIL(args.push_back(oracle_mode))) {7292
LOG_WARN("push_back error", K(ret));7293
} else if (OB_FAIL(args.push_back(ret_err))) {7294
LOG_WARN("push_back error", K(ret));7295
} else if (OB_FAIL(args.push_back(type_ptr))) {7296
LOG_WARN("push_back error", K(ret));7297
} else if (OB_FAIL(args.push_back(error_code_ptr))) {7298
LOG_WARN("push_back error", K(ret));7299
} else if (OB_FAIL(args.push_back(sql_state_ptr))) {7300
LOG_WARN("push_back error", K(ret));7301
} else if (OB_FAIL(args.push_back(str_len_ptr))) {7302
LOG_WARN("push_back error", K(ret));7306
ObLLVMValue error_code;
7307
ObLLVMValue sql_state;
7308
ObLLVMValue str_len;
7309
ObLLVMValue stmt_id_value;
7310
ObLLVMValue line_number_value;
7311
// stmt id目前是col和line的组合，暂时先用这个
7312
int64_t line_number = stmt_id;
7313
if (OB_FAIL(helper_.get_int64(line_number, line_number_value))) {7314
LOG_WARN("failed to get_line_number", K(ret));7315
} else if (OB_FAIL(helper_.get_int64(stmt_id, stmt_id_value))) {7316
LOG_WARN("failed to get_int64", K(ret));7317
} else if (OB_FAIL(helper_.create_call(ObString("convert_exception"), get_eh_service().eh_convert_exception_, args, result))) {7318
LOG_WARN("failed to create_call", K(ret));7319
} else if (OB_FAIL(helper_.create_load(ObString("load_type"), type_ptr, type))) {7320
LOG_WARN("failed to create_load", K(ret));7321
} else if (OB_FAIL(helper_.create_load(ObString("load_error_code"), error_code_ptr, error_code))) {7322
LOG_WARN("failed to create_load", K(ret));7323
} else if (OB_FAIL(helper_.create_load(ObString("load_sql_state"), sql_state_ptr, sql_state))) {7324
LOG_WARN("failed to create_load", K(ret));7325
} else if (OB_FAIL(helper_.create_load(ObString("load_str_len"), str_len_ptr, str_len))) {7326
LOG_WARN("failed to create_load", K(ret));7327
} else if (OB_FAIL(generate_exception(type, ret_err, error_code, sql_state, str_len, stmt_id_value, success_branch, line_number_value, in_notfound, in_warning, signal))) {7328
LOG_WARN("failed to generate exception", K(ret));7329
} else if (OB_FAIL(set_current(success_branch))) {7330
LOG_WARN("failed to set_current", K(ret));7331
} else { /*do nothing*/ }7339
int ObPLCodeGenerator::finish_current(const ObLLVMBasicBlock &next)
7341
int ret = OB_SUCCESS;
7342
if (NULL == get_current().get_v()) {7343
//如果current为NULL，说明控制流已经被显式切走了（例如Iterate、Leave语句）
7344
} else if (get_current().get_v() == get_exit().get_v()) {7345
//如果current是exit，说明控制流已经显式结束（如return）
7346
} else if (OB_FAIL(helper_.set_insert_point(get_current()))) {7347
LOG_WARN("failed to set insert point", K(ret));7348
} else if (OB_FAIL(helper_.create_br(next))) {7349
LOG_WARN("failed to create br", K(ret));7350
} else { /*do nothing*/ }7354
int ObPLCodeGenerator::generate_prototype()
7356
int ret = OB_SUCCESS;
7357
ObSEArray<ObLLVMType, 8> arg_types;
7358
ObLLVMFunctionType ft;
7359
ObLLVMType pl_exec_context_type;
7360
ObLLVMType pl_exec_context_pointer_type;
7361
ObLLVMType argv_type;
7362
ObLLVMType argv_pointer_type;
7363
if (OB_FAIL(adt_service_.get_pl_exec_context(pl_exec_context_type))) {7364
LOG_WARN("failed to get argv type", K(ret));7365
} else if (OB_FAIL(pl_exec_context_type.get_pointer_to(pl_exec_context_pointer_type))) {7366
LOG_WARN("failed to get_pointer_to", K(ret));7367
} else if (OB_FAIL(adt_service_.get_argv(argv_type))) {7368
LOG_WARN("failed to get argv type", K(ret));7369
} else if (OB_FAIL(argv_type.get_pointer_to(argv_pointer_type))) {7370
LOG_WARN("failed to get_pointer_to", K(ret));7371
} else { /*do nothing*/ }7374
ObLLVMType int64_type;
7375
if (OB_FAIL(arg_types.push_back(pl_exec_context_pointer_type))) { //函数第一个参数必须是基础环境信息隐藏参数ObPLExecCtx*7376
LOG_WARN("push_back error", K(ret));7377
} else if (OB_FAIL(helper_.get_llvm_type(ObIntType, int64_type))) {7378
LOG_WARN("failed to get_llvm_type", K(ret));7379
} else if (OB_FAIL(arg_types.push_back(int64_type))) { //第二个参数是int64_t ArgC7380
LOG_WARN("push_back error", K(ret));7381
} else if (OB_FAIL(arg_types.push_back(argv_pointer_type))) { //第三个参数是int64_t[] ArgV7382
LOG_WARN("push_back error", K(ret));7383
} else { /*do nothing*/ }7387
if (get_ast().get_ret_type().is_obj_type()
7388
&& (OB_ISNULL(get_ast().get_ret_type().get_data_type())
7389
|| get_ast().get_ret_type().get_data_type()->get_meta_type().is_invalid())) {7390
ret = OB_ERR_UNEXPECTED;
7391
LOG_WARN("return type is invalid", K(func_), K(ret));7393
ObLLVMType ret_type;
7394
ObLLVMFunctionType ft;
7395
if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, ret_type))) {7396
LOG_WARN("failed to get_llvm_type", K(ret));7397
} else if (OB_FAIL(ObLLVMFunctionType::get(ret_type, arg_types, ft))) {7398
LOG_WARN("failed to get function type", K(ret));7399
} else if (OB_FAIL(helper_.create_function(get_ast().get_name(), ft, func_))) {7400
LOG_WARN("failed to create function", K(ret));7401
} else { /*do nothing*/ }7409
if (OB_FAIL(func_.get_argument_size(size))) {7410
LOG_WARN("failed to get argument size", K(ret));7413
int64_t i = CTX_IDX;
7414
for (int64_t j = 0; OB_SUCC(ret) && j < size; ++j) {7415
if (OB_FAIL(func_.get_argument(j, arg))) {7416
LOG_WARN("failed to get argument", K(j), K(ret));7417
} else if (OB_FAIL(arg.set_name(ArgName[i]))) {7418
LOG_WARN("failed to set name", K(j), K(ret));7420
vars_.at(i++) = arg;
7428
int ObPLCodeGenerator::unset_debug_location()
7430
int ret = OB_SUCCESS;
7432
jit::ObLLVMDIScope scope;
7433
if (OB_FAIL(di_helper_.get_current_scope(scope))) {7434
LOG_WARN("failed to set debug location", K(ret));7435
} else if (OB_FAIL(helper_.unset_debug_location(&scope))) {7436
LOG_WARN("failed to unset debug location", K(ret));7442
int ObPLCodeGenerator::set_debug_location(const ObPLStmt &s)
7444
int ret = OB_SUCCESS;
7446
uint32_t line = s.get_line() + 1;
7447
uint32_t col = s.get_col();
7448
jit::ObLLVMDIScope scope;
7449
if (OB_FAIL(di_helper_.get_current_scope(scope))) {7450
LOG_WARN("failed to get current scope", K(line), K(col), K(ret));7451
} else if (OB_FAIL(helper_.set_debug_location(line, col, &scope))) {7452
LOG_WARN("failed to set debug location", K(line), K(col), K(ret));7458
int ObPLCodeGenerator::get_di_llvm_type(const ObPLDataType &pl_type, ObLLVMDIType &di_type)
7460
int ret = OB_SUCCESS;
7462
if (pl_type.is_obj_type()) {7463
if (OB_FAIL(di_adt_service_.get_di_type(pl_type.get_obj_type(), di_type))) {7464
LOG_WARN("failed to get di type", K(ret));7466
} else if (pl_type.is_user_type()) {7467
uint64_t user_type_id = pl_type.get_user_type_id();
7468
if (OB_FAIL(di_user_type_map_.get_refactored(user_type_id, di_type))) {7469
LOG_WARN("failed to get di user type map", K(user_type_id), K(ret));7472
ret = OB_ERR_UNEXPECTED;
7473
LOG_WARN("pl type is invalid", K(pl_type.get_type()));7479
int ObPLCodeGenerator::get_di_datum_type(const ObPLDataType &pl_type, ObLLVMDIType &di_type)
7481
int ret = OB_SUCCESS;
7483
if (pl_type.is_obj_type()) {7484
// why we call get_datum_type(), not get_di_type().
7485
// see ObPLCodeGenerate::get_datum_type().
7486
if (OB_FAIL(di_adt_service_.get_datum_type(pl_type.get_obj_type(), di_type))) {7487
LOG_WARN("failed to get datum type", K(ret));7489
} else if (pl_type.is_user_type()) {7490
uint64_t user_type_id = pl_type.get_user_type_id();
7491
if (OB_FAIL(di_user_type_map_.get_refactored(user_type_id, di_type))) {7492
LOG_WARN("failed to get di user type map", K(user_type_id), K(ret));7495
ret = OB_ERR_UNEXPECTED;
7496
LOG_WARN("pl type is invalid", K(pl_type.get_type()));7502
int ObPLCodeGenerator::generate_di_user_type(const ObUserDefinedType &type, uint32_t line)
7504
int ret = OB_SUCCESS;
7505
if (debug_mode_ && false) {7506
if (type.is_record_type()) {7507
const ObRecordType &record_type = static_cast<const ObRecordType&>(type);
7508
if (OB_FAIL(generate_di_record_type(record_type, line))) {7509
LOG_WARN("failed to generate di record type", K(ret));7511
#ifdef OB_BUILD_ORACLE_PL
7512
} else if (type.is_nested_table_type()) {7513
const ObNestedTableType &table_type = static_cast<const ObNestedTableType&>(type);
7514
if (OB_FAIL(generate_di_table_type(table_type, line))) {7515
LOG_WARN("failed to generate di table type", K(ret));7519
ret = OB_ERR_UNEXPECTED;
7520
LOG_WARN("user defined type is invalid", K(type.get_type()));7526
#ifdef OB_BUILD_ORACLE_PL
7527
int ObPLCodeGenerator::generate_di_table_type(const ObNestedTableType &table_type, uint32_t line)
7529
int ret = OB_SUCCESS;
7531
const ObString &type_name = table_type.get_name();
7532
const ObPLDataType &data_type = table_type.get_element_type();
7533
ObLLVMDIType element_type;
7534
ObLLVMDIType di_table_type;
7535
uint64_t type_id = table_type.get_user_type_id();
7536
if (OB_FAIL(get_di_datum_type(data_type, element_type))) {7537
LOG_WARN("failed to get di datum type", K(ret));7538
} else if (OB_FAIL(di_adt_service_.get_table_type(type_name, line, element_type, di_table_type))) {7539
LOG_WARN("failed to get array type", K(ret));7540
} else if (OB_FAIL(di_user_type_map_.set_refactored(type_id, di_table_type))) {7541
LOG_WARN("failed to set di table type to user type map", K(ret), K(table_type));7548
int ObPLCodeGenerator::generate_di_record_type(const ObRecordType &record_type, uint32_t line)
7550
int ret = OB_SUCCESS;
7552
ObSEArray<ObString, 8> cell_names;
7553
ObSEArray<ObLLVMDIType, 8> cell_types;
7554
ObLLVMDIType di_record_type;
7555
for (int64_t i = 0; OB_SUCC(ret) && i < record_type.get_record_member_count(); ++i) {7556
const ObString *cell_name = record_type.get_record_member_name(i);
7557
const ObPLDataType *data_type = record_type.get_record_member_type(i);
7558
ObLLVMDIType cell_type;
7559
if (OB_ISNULL(cell_name) || OB_ISNULL(data_type)) {7560
ret = OB_ERR_UNEXPECTED;
7561
LOG_WARN("cell name or data type is null");7562
} else if (OB_FAIL(get_di_datum_type(*data_type, cell_type))) {7563
LOG_WARN("failed to get di datum type", K(i), K(*data_type), K(ret));7564
} else if (OB_FAIL(cell_names.push_back(*cell_name))) {7565
LOG_WARN("failed to push back cell name", K(ret));7566
} else if (OB_FAIL(cell_types.push_back(cell_type))) {7567
LOG_WARN("failed to push back cell type", K(ret));7571
const ObString &type_name = record_type.get_name();
7572
uint64_t type_id = record_type.get_user_type_id();
7573
if (OB_FAIL(di_adt_service_.get_record_type(type_name, line, cell_names, cell_types, di_record_type))) {7574
LOG_WARN("failed to get record type", K(record_type), K(ret));7575
} else if (OB_FAIL(di_user_type_map_.set_refactored(type_id, di_record_type))) {7576
LOG_WARN("failed to set di record type to user type map", K(record_type), K(ret));7583
int ObPLCodeGenerator::generate_di_argument()
7585
int ret = OB_SUCCESS;
7587
ObLLVMDIType di_ret_type;
7588
ObLLVMDIType di_ctx_type;
7589
ObLLVMDIType di_argc_type;
7590
ObLLVMDIType di_argv_type;
7591
ObLLVMDIType di_argv_ptr_type;
7592
if (OB_FAIL(di_adt_service_.get_obj_type(ObInt32Type, di_ret_type))) {7593
LOG_WARN("failed to get element di type", K(ret));7594
} else if (OB_FAIL(di_adt_service_.get_exec_ctx(di_ctx_type))) {7595
LOG_WARN("failed to get element di type", K(ret));7596
} else if (OB_FAIL(di_adt_service_.get_obj_type(ObIntType, di_argc_type))) {7597
LOG_WARN("failed to get element di type", K(ret));7598
} else if (OB_FAIL(di_adt_service_.get_argv(get_ast().get_arg_count(), di_argv_type))) {7599
LOG_WARN("failed to get element di type", K(ret));7600
} else if (OB_FAIL(di_helper_.create_pointer_type(di_argv_type, di_argv_ptr_type))) {7601
LOG_WARN("failed to create di poiner type", K(ret));7607
int ObPLCodeGenerator::generate_di_local_variable(const ObPLVar &var,
7608
uint32_t arg_no, uint32_t line, ObLLVMValue &value)
7610
int ret = OB_SUCCESS;
7613
if (OB_FAIL(get_di_llvm_type(var.get_type(), type))) {7614
LOG_WARN("failed to get llvm di type", K(ret));7615
} else if (OB_FAIL(generate_di_local_variable(var.get_name(), type, arg_no, line, value))) {7616
LOG_WARN("failed to generate di local variable", K(ret));7622
int ObPLCodeGenerator::generate_di_local_variable(const ObString &name, ObLLVMDIType &type,
7623
uint32_t arg_no, uint32_t line, ObLLVMValue &value)
7625
int ret = OB_SUCCESS;
7627
ObLLVMBasicBlock block;
7628
ObLLVMDILocalVariable variable;
7629
if (OB_FAIL(helper_.get_insert_block(block))) {7630
LOG_WARN("failed to get insert block", K(name), K(ret));7631
} else if (OB_FAIL(di_helper_.create_local_variable(name, arg_no, line, type, variable))) {7632
LOG_WARN("failed to create di local variable", K(name), K(ret));7633
} else if (OB_FAIL(di_helper_.insert_declare(value, variable, block))) {7634
LOG_WARN("failed to insert declare", K(name), K(ret));7640
int ObPLCodeGenerator::init_di_adt_service()
7642
int ret = OB_SUCCESS;
7645
if (get_ast().get_package_name().empty()) {7646
CK (!get_ast().get_db_name().empty());
7647
OZ (sql.append_fmt("%.*s.%.*s",7648
get_ast().get_db_name().length(), get_ast().get_db_name().ptr(),
7649
get_ast().get_name().length(), get_ast().get_name().ptr()));
7651
CK (!get_ast().get_db_name().empty());
7652
OZ (sql.append_fmt("%.*s.%.*s.%.*s",7653
get_ast().get_db_name().length(), get_ast().get_db_name().ptr(),
7654
get_ast().get_package_name().length(), get_ast().get_package_name().ptr(),
7655
get_ast().get_name().length(), get_ast().get_name().ptr()));
7658
} else if (OB_FAIL(di_adt_service_.init(sql.ptr()))) {7659
LOG_WARN("failed to init di service", K(ret));7665
int ObPLCodeGenerator::generate_di_prototype()
7667
int ret = OB_SUCCESS;
7671
ObLLVMDIType ret_type;
7672
ObLLVMDIType pl_exec_ctx_type;
7673
ObLLVMDIType pl_exec_ctx_ptr_type;
7674
ObLLVMDIType argc_type;
7675
ObLLVMDIType argv_type;
7676
ObLLVMDIType argv_ptr_type;
7677
ObSEArray<ObLLVMDIType, 8> member_types;
7678
ObLLVMDISubroutineType sr_type;
7679
ObLLVMDISubprogram sp;
7680
if (get_ast().get_package_name().empty()) {7681
CK (!get_ast().get_db_name().empty());
7682
OZ (sql.append_fmt("%.*s.%.*s",7683
get_ast().get_db_name().length(), get_ast().get_db_name().ptr(),
7684
get_ast().get_name().length(), get_ast().get_name().ptr()));
7686
CK (!get_ast().get_db_name().empty());
7687
OZ (sql.append_fmt("%.*s.%.*s.%.*s",7688
get_ast().get_db_name().length(), get_ast().get_db_name().ptr(),
7689
get_ast().get_package_name().length(), get_ast().get_package_name().ptr(),
7690
get_ast().get_name().length(), get_ast().get_name().ptr()));
7693
} else if (OB_FAIL(func_.get_argument_size(argc))) {7694
LOG_WARN("failed to get argument size", K(ret));7695
} else if (OB_FAIL(di_adt_service_.get_obj_type(ObInt32Type, ret_type))) {7696
LOG_WARN("failed to get di ret type", K(ret));7697
} else if (OB_FAIL(di_adt_service_.get_exec_ctx(pl_exec_ctx_type))) {7698
LOG_WARN("failed to get di pl exec ctx type", K(ret));7699
} else if (OB_FAIL(di_helper_.create_pointer_type(pl_exec_ctx_type, pl_exec_ctx_ptr_type))) {7700
LOG_WARN("failed to create di poiner type", K(ret));7701
} else if (OB_FAIL(di_adt_service_.get_obj_type(ObIntType, argc_type))) {7702
LOG_WARN("failed to get di argc type", K(ret));7703
} else if (OB_FAIL(di_adt_service_.get_argv(argc, argv_type))) {7704
LOG_WARN("failed to get di argv type", K(ret));7705
} else if (OB_FAIL(di_helper_.create_pointer_type(argv_type, argv_ptr_type))) {7706
LOG_WARN("failed to create di poiner type", K(ret));7707
} else if (OB_FAIL(member_types.push_back(ret_type))) {7708
LOG_WARN("failed to push back di ret type", K(ret));7709
} else if (OB_FAIL(member_types.push_back(pl_exec_ctx_ptr_type))) {7710
LOG_WARN("failed to push back di pl exec ctx type", K(ret));7711
} else if (OB_FAIL(member_types.push_back(argc_type))) {7712
LOG_WARN("failed to push back di argc type", K(ret));7713
} else if (OB_FAIL(member_types.push_back(argv_ptr_type))) {7714
LOG_WARN("failed to push back di argv type", K(ret));7715
} else if (OB_FAIL(di_helper_.create_subroutine_type(member_types, sr_type))) {7716
LOG_WARN("failed to create di subroutine type", K(ret));7717
} else if (OB_ISNULL(sr_type.get_v())) {7718
ret = OB_ERR_UNEXPECTED;
7719
LOG_WARN("failed to create di subroutine type", K(ret));7720
} else if (OB_FAIL(di_helper_.create_function(sql.ptr(), sr_type, sp))) {7721
LOG_WARN("failed to create di subprogram", K(ret));7723
func_.set_subprogram(&sp);
7729
int ObPLCodeGenerator::init_argument()
7731
int ret = OB_SUCCESS;
7732
ObLLVMValue int32_value;
7733
if (OB_FAIL(helper_.create_ialloca(ObString(ArgName[RET_IDX]), ObInt32Type, OB_SUCCESS, vars_.at(RET_IDX)))) {7734
LOG_WARN("failed to create_alloca", K(ret));7735
} else if (OB_FAIL(helper_.get_int32(OB_SUCCESS, int32_value))) {7736
LOG_WARN("failed to get_int32", K(ret));7737
} else if (OB_FAIL(helper_.create_store(int32_value, vars_.at(RET_IDX)))) {7738
LOG_WARN("failed to create_store", K(ret));7739
} else if (OB_FAIL(unset_debug_location())) {7740
LOG_WARN("failed to unset debug location", K(ret));7742
for (int64_t i = 0; i < get_ast().get_arg_count(); ++i) {7743
const ObPLVar *var = get_ast().get_symbol_table().get_symbol(i);
7744
if (OB_ISNULL(var)) {7745
ret = OB_ERR_UNEXPECTED;
7746
LOG_WARN("var is NULL", K(i), K(var), K(ret));7750
ObLLVMValue init_value;
7751
if (var->get_type().is_composite_type() || var->get_type().is_cursor_type()) {7752
if (OB_FAIL(extract_objparam_from_argv(vars_.at(ARGV_IDX), i, arg))) {7753
LOG_WARN("failed to extract_objparam_from_argv", K(i), K(ret));7754
} else if (OB_FAIL(extract_value_from_objparam(arg, ObExtendType, addr))) {7755
LOG_WARN("failed to extract_value_from_objparam", K(ret));7756
} else if (OB_FAIL(helper_.get_int32(0, init_value))) {7757
LOG_WARN("failed to get_int32", K(ret));7758
} else if (OB_FAIL(set_var_addr_to_param_store(i, addr, init_value))) {7759
LOG_WARN("set var addr to param store failed", K(ret));7760
} else if (OB_FAIL(helper_.create_gep(ObString("obj"), arg, 0, arg))) {7761
LOG_WARN("failed to create_gep", K(ret));7763
get_vars().at(i + USER_ARG_OFFSET) = arg;
7765
} else if (OB_ISNULL(var->get_type().get_data_type())) {7766
ret = OB_ERR_UNEXPECTED;
7767
LOG_WARN("basic pl type got null data type is unexpected", K(ret), K(var->get_type()));7769
const ObDataType &data_type = *(var->get_type().get_data_type());
7771
if (OB_FAIL(extract_datum_from_argv(vars_.at(ARGV_IDX), i, data_type.get_obj_type(), arg))) {7772
LOG_WARN("failed to extract_datum_from_argv", K(ret));7773
} else if (OB_FAIL(ObPLDataType::get_llvm_type(data_type.get_obj_type(), helper_, adt_service_, ir_type))) {7774
LOG_WARN("failed to get_ir_type", K(data_type.get_obj_type()), K(ret));7775
} else if (OB_FAIL(helper_.create_alloca(var->get_name(), ir_type, vars_.at(i + USER_ARG_OFFSET)))) {7776
LOG_WARN("failed to create_alloca", K(ret));7777
} else if (OB_FAIL(helper_.create_store(arg, vars_.at(i + USER_ARG_OFFSET)))) {7778
LOG_WARN("failed to create_store", K(ret));7787
int ObPLCodeGenerator::prepare_local_user_type()
7789
int ret = OB_SUCCESS;
7790
int64_t count = ast_.get_user_type_table().get_count();
7791
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {7792
const ObUserDefinedType *user_type = ast_.get_user_type_table().get_type(i);
7793
CK (OB_NOT_NULL(user_type));
7794
OZ (generate_user_type(*user_type), K(i), KPC(user_type));
7799
int ObPLCodeGenerator::prepare_external()
7801
int ret = OB_SUCCESS;
7802
int64_t count = ast_.get_user_type_table().get_external_types().count();
7803
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {7804
const ObUserDefinedType *user_type = ast_.get_user_type_table().get_external_types().at(i);
7805
CK (OB_NOT_NULL(user_type));
7806
OZ (generate_user_type(*user_type), K(i), K(count), KPC(user_type));
7808
LOG_DEBUG("pl/sql code generator prepare_external types",7810
K(ast_.get_user_type_table().get_external_types().count()),
7811
K(ast_.get_user_type_table().get_external_types()),
7812
K(&(ast_.get_user_type_table().get_external_types())),
7814
K(ast_.get_db_name()),
7820
int ObPLCodeGenerator::prepare_expression(ObPLCompileUnit &pl_func)
7822
int ret = OB_SUCCESS;
7823
ObArray<ObSqlExpression*> array;
7824
for (int64_t i = 0; OB_SUCC(ret) && i < ast_.get_exprs().count(); ++i) {7825
ObSqlExpression *expr = NULL;
7826
if (OB_FAIL(pl_func.get_sql_expression_factory().alloc(expr))) {7827
LOG_WARN("failed to alloc expr", K(ret));7828
} else if (OB_ISNULL(expr)) {7829
ret = OB_ERR_UNEXPECTED;
7830
LOG_WARN("failed to create expr", K(ret));7831
} else if (OB_FAIL(array.push_back(expr))) {7832
LOG_WARN("push back error", K(ret));7833
} else { /*do nothing*/ }7836
if (OB_FAIL(pl_func.set_expressions(array))) {7837
LOG_WARN("failed to set expressions", K(ret));7843
int ObPLCodeGenerator::prepare_subprogram(ObPLFunction &pl_func)
7845
int ret = OB_SUCCESS;
7846
OZ (ObPLCompiler::compile_subprogram_table(allocator_,
7848
pl_func.get_exec_env(),
7849
ast_.get_routine_table(),
7855
int ObPLCodeGenerator::generate_obj_access_expr()
7857
int ret = OB_SUCCESS;
7858
for (int64_t i = 0; OB_SUCC(ret) && i < ast_.get_obj_access_exprs().count(); ++i) {7859
const ObRawExpr *expr = ast_.get_obj_access_expr(i);
7860
if (OB_ISNULL(expr)) {7861
ret = OB_ERR_UNEXPECTED;
7862
LOG_WARN("expr is null", K(i), K(ast_.get_obj_access_exprs()), K(ret));7863
} else if (!expr->is_obj_access_expr()) {7864
ret = OB_ERR_UNEXPECTED;
7865
LOG_WARN("expr is not obj access", K(i), K(*expr), K(ret));7867
const ObObjAccessRawExpr *obj_access_expr = static_cast<const ObObjAccessRawExpr*>(expr);
7868
if (OB_FAIL(generate_get_attr_func(
7869
obj_access_expr->get_access_idxs(),
7870
obj_access_expr->get_var_indexs().count() + obj_access_expr->get_param_count(),
7871
obj_access_expr->get_func_name(),
7872
obj_access_expr->for_write()))) {7873
LOG_WARN("generate get attr function failed",7875
K(obj_access_expr->get_access_idxs()),
7876
K(obj_access_expr->get_func_name()));
7884
* 把ObObjAccessRawExpr翻译成一个函数，其中的每个ObObjAccessIdx可能是：
7885
* 1、const，即常量，只能出现在表的下标位置，如a(1)里的1;
7886
* 2、property,即固有属性，只能出现在表的属性位置，如a.count里的count；
7887
* 3、local,即PL内部变量，可能出现在
7888
* 1）、初始内存位置，如a(1)里的a；
7889
* 2）、表的下标位置，如a(i)里的i；
7890
* 3）、record的属性位置，如a.b里的b；
7891
* 4、external（包括IS_PKG、IS_USER、IS_SESSION、IS_GLOBAL），可能出现在
7892
* 1）、初始内存位置，如a(1)里的a；
7893
* 2）、表的下标位置，如a(i)里的i；
7894
* 3）、record的属性位置，如a.b里的b；
7895
* 5、ns不可能出现，在resolver阶段已经被剥掉了。
7899
* 3、因为把变量在param store里的下标放在var_indexs_里，所以根据var_indexs_从param store里取出值使用；
7900
* 4、因为把计算的结果作为ObObjAccessRawExpr的child传给了表达式计算，所以直接取obj_stack的值使用。
7902
* int32_t get_func(int64_t param_cnt, int64_t* params, int64_t* element_val);
7904
int ObPLCodeGenerator::generate_get_attr_func(const ObIArray<ObObjAccessIdx> &idents,
7905
int64_t param_count, const ObString &func_name,
7908
int ret = OB_SUCCESS;
7909
ObSEArray<ObLLVMType, 4> arg_types;
7910
ObLLVMFunctionType ft;
7911
ObLLVMType bool_type;
7912
ObLLVMType array_type;
7913
ObLLVMType array_pointer_type;
7914
ObLLVMType int64_type;
7915
ObLLVMType int32_type;
7916
ObLLVMType int64_pointer_type;
7918
OZ (helper_.get_llvm_type(ObIntType, int64_type));
7919
OZ (helper_.get_llvm_type(ObInt32Type, int32_type));
7920
OZ (helper_.get_array_type(int64_type, param_count, array_type));
7921
OZ (array_type.get_pointer_to(array_pointer_type));
7922
OZ (int64_type.get_pointer_to(int64_pointer_type));
7924
OZ (arg_types.push_back(int64_type));
7925
OZ (arg_types.push_back(array_pointer_type));
7926
OZ (arg_types.push_back(int64_pointer_type));
7927
OZ (ObLLVMFunctionType::get(int32_type, arg_types, ft));
7928
OZ (helper_.create_function(func_name, ft, func_));
7930
OZ (helper_.create_block(ObString("entry"), func_, entry_));7931
OZ (helper_.create_block(ObString("exit"), func_, exit_));7932
OZ (set_current(entry_));
7936
ObLLVMValue param_cnt;
7937
ObLLVMValue params_ptr;
7938
ObLLVMValue element_value;
7939
ObLLVMValue result_value_ptr;
7940
ObLLVMValue ret_value_ptr;
7941
ObLLVMValue ret_value;
7942
OZ (func_.get_argument(0,param_cnt));
7943
OZ (param_cnt.set_name(ObString("param_cnt")));7944
OZ (func_.get_argument(1, params_ptr));
7945
OZ (params_ptr.set_name(ObString("param_array")));7946
OZ (func_.get_argument(2, result_value_ptr));
7947
OZ (result_value_ptr.set_name(ObString("result_value_ptr")));7948
OZ (helper_.create_alloca(ObString("ret_value"), int32_type, ret_value_ptr));7950
OZ (generate_get_attr(params_ptr, idents, for_write,
7951
result_value_ptr, ret_value_ptr, exit_), idents);
7953
OZ (helper_.create_br(exit_));
7954
OZ (helper_.set_insert_point(exit_));
7955
OZ (helper_.create_load(ObString("load_ret_value"), ret_value_ptr, ret_value));7956
OZ (helper_.create_ret(ret_value));
7961
int ObPLCodeGenerator::final_expression(ObPLCompileUnit &pl_func)
7963
int ret = OB_SUCCESS;
7964
for (int64_t i = 0; OB_SUCC(ret) && i < ast_.get_obj_access_exprs().count(); ++i) {7965
ObRawExpr *expr = ast_.get_obj_access_expr(i);
7966
if (OB_ISNULL(expr)) {7967
ret = OB_ERR_UNEXPECTED;
7968
LOG_WARN("obj_access_expr is null");7969
} else if (!expr->is_obj_access_expr()) {7970
ret = OB_ERR_UNEXPECTED;
7971
LOG_WARN("not a obj access", K(*expr), K(ret));7973
ObObjAccessRawExpr* obj_access_expr = static_cast<ObObjAccessRawExpr*>(expr);
7974
obj_access_expr->set_get_attr_func_addr(helper_.get_function_address(obj_access_expr->get_func_name()));
7980
// generate static engine expressions
7981
sql::ObRawExprUniqueSet raw_exprs(false);
7982
for (int64_t i = 0; OB_SUCC(ret) && i < ast_.get_exprs().count(); i++) {7983
OZ(raw_exprs.append(ast_.get_expr(i)));
7985
sql::ObStaticEngineExprCG se_cg(pl_func.get_allocator(),
7988
0 /* original param cnt */,
7990
GET_MIN_CLUSTER_VERSION());
7991
se_cg.set_rt_question_mark_eval(true);
7992
OZ(se_cg.generate(raw_exprs, pl_func.get_frame_info()));
7994
uint32_t expr_op_size = 0;
7996
ObExprGeneratorImpl expr_generator(pl_func.get_expr_operator_factory(), 0, 0,
7997
&expr_op_size, row_desc);
7998
for (int64_t i = 0; OB_SUCC(ret) && i < ast_.get_exprs().count(); ++i) {7999
ObRawExpr *raw_expr = ast_.get_expr(i);
8000
ObSqlExpression *expression = static_cast<ObSqlExpression*>(get_expr(i));
8001
if (OB_ISNULL(raw_expr) || OB_ISNULL(expression)) {8002
ret = OB_INVALID_ARGUMENT;
8003
LOG_WARN("Invalid arguments", K(i), K(raw_expr), K(expression), K(ret));8005
// TODO bin.lb: No need to generate expression if static engine enabled
8007
if (OB_FAIL(expr_generator.generate(*raw_expr, *expression))) {8008
SQL_LOG(WARN, "Generate post_expr error", K(ret), KPC(raw_expr));
8010
expression->set_expr(raw_expr->rt_expr_);
8015
pl_func.set_expr_op_size(std::max(pl_func.get_frame_info().need_ctx_cnt_,
8016
static_cast<int64_t>(expr_op_size)));
8023
int ObPLCodeGenerator::generate_goto_label(const ObPLStmt &stmt)
8025
int ret = OB_SUCCESS;
8026
if (stmt.get_is_goto_dst()) {8028
if (NULL == get_current().get_v()) {8031
// 去看一下对应的goto是否已经cg了，没有的话就记录一下这个label地址。
8033
hash::HashMapPair<ObPLCodeGenerator::goto_label_flag, std::pair<ObLLVMBasicBlock, ObLLVMBasicBlock>> pair;
8034
int tmp_ret = get_goto_label_map().get_refactored(stmt.get_stmt_id(), pair);
8035
if (OB_HASH_NOT_EXIST == tmp_ret) {8036
ObLLVMBasicBlock label_block;
8037
ObLLVMBasicBlock stack_save_block;
8038
const ObString *lab = stmt.get_label();
8039
if (OB_FAIL(get_helper().create_block(NULL == lab ? ObString("") : *lab, get_func(),8041
LOG_WARN("create goto label failed", K(ret));8042
} else if (OB_FAIL(get_helper().create_block(NULL == lab ? ObString("") : *lab, get_func(),8043
stack_save_block))) {8044
LOG_WARN("create goto label failed", K(ret));8045
} else if (OB_FAIL(get_helper().create_br(stack_save_block))) {8046
LOG_WARN("failed to create_br", K(ret));8047
} else if (OB_FAIL(get_helper().set_insert_point(stack_save_block))) {8048
LOG_WARN("failed to set insert point", K(ret));8049
} else if (OB_FAIL(set_current(stack_save_block))) {8050
LOG_WARN("failed to set current block", K(ret));8051
} else if (OB_FAIL(get_helper().stack_save(stack))) {8052
LOG_WARN("failed to save current stack", K(ret));8053
} else if (OB_FAIL(get_helper().create_br(label_block))) {8054
LOG_WARN("failed to create_br", K(ret));8055
} else if (OB_FAIL(get_helper().set_insert_point(label_block))) {8056
LOG_WARN("failed to set insert point", K(ret));8057
} else if (OB_FAIL(set_current(label_block))) {8058
LOG_WARN("failed to set current block", K(ret));8059
} else if (OB_FAIL(get_helper().stack_restore(stack))) {8060
LOG_WARN("failed to restore stack", K(ret));8061
} else if (OB_FAIL(pair.init(ObPLCodeGenerator::goto_label_flag::GOTO_LABEL_CG,
8062
std::pair<ObLLVMBasicBlock, ObLLVMBasicBlock>(stack_save_block, label_block)))) {8063
LOG_WARN("init label block pair failed.", K(ret));8064
} else if (OB_FAIL(get_goto_label_map().set_refactored(stmt.get_stmt_id(), pair))) {8065
LOG_WARN("set label block failed", K(ret));8067
} else if (OB_SUCCESS == tmp_ret) {8068
ObLLVMBasicBlock &stack_save_block = pair.second.first;
8069
ObLLVMBasicBlock &goto_block = pair.second.second;
8070
if (OB_FAIL(get_helper().create_br(stack_save_block))) {8071
LOG_WARN("failed to create_br", K(ret));8072
} else if (OB_FAIL(get_helper().set_insert_point(stack_save_block))) {8073
LOG_WARN("failed to set insert point", K(ret));8074
} else if (OB_FAIL(set_current(stack_save_block))) {8075
LOG_WARN("failed to set current block", K(ret));8076
} else if (OB_FAIL(get_helper().stack_save(stack))) {8077
LOG_WARN("failed to save stack", K(ret));8078
} else if (OB_FAIL(get_helper().create_br(goto_block))) {8079
LOG_WARN("failed to create_br", K(ret));8080
} else if (OB_FAIL(get_helper().set_insert_point(goto_block))) {8081
LOG_WARN("failed to set insert point", K(ret));8082
} else if (OB_FAIL(set_current(goto_block))) {8083
LOG_WARN("failed to set current block", K(ret));8084
} else if (OB_FAIL(get_helper().stack_restore(stack))) {8085
LOG_WARN("failed to restore stack", K(ret));8087
pair.first = ObPLCodeGenerator::goto_label_flag::GOTO_LABEL_CG;
8088
if (OB_FAIL(get_goto_label_map().set_refactored(stmt.get_stmt_id(), pair, true))) {8089
LOG_WARN("set label block failed", K(ret));8093
ret = OB_ERR_UNEXPECTED;
8094
LOG_WARN("failed to label block", K(ret));8103
int ObPLCodeGenerator::generate_destruct_obj(const ObPLStmt &s, ObLLVMValue &src_datum)
8105
int ret = OB_SUCCESS;
8106
ObSEArray<jit::ObLLVMValue, 2> args;
8108
OZ (args.push_back(get_vars()[CTX_IDX]));
8109
OZ (args.push_back(src_datum));
8111
jit::ObLLVMValue ret_err;
8112
if (OB_FAIL(get_helper().create_call(ObString("spi_destruct_obj"), get_spi_service().spi_destruct_obj_, args, ret_err))) {8113
LOG_WARN("failed to create call", K(ret));8114
} else if (OB_FAIL(check_success(ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()))) {8115
LOG_WARN("failed to check success", K(ret));8116
} else { /*do nothing*/ }8121
int ObPLCodeGenerator::generate_out_param(
8122
const ObPLStmt &s, const ObIArray<InOutParam> ¶m_desc, ObLLVMValue ¶ms, int64_t i)
8124
int ret = OB_SUCCESS;
8125
ObLLVMType obj_param_type;
8126
ObLLVMType obj_param_type_pointer;
8129
OZ (get_adt_service().get_objparam(obj_param_type));
8130
OZ (obj_param_type.get_pointer_to(obj_param_type_pointer));
8132
OZ (extract_arg_from_argv(params, i, pp_arg));
8133
OZ (get_helper().create_load("load_out_arg_pointer", pp_arg, p_arg));8134
OZ (get_helper().create_int_to_ptr(
8135
ObString("cast_pointer_to_arg"), p_arg, obj_param_type_pointer, p_arg));8138
} else if (OB_INVALID_INDEX != param_desc.at(i).out_idx_) { // 处理本地变量8139
//存储进全局符号表和param store
8141
ObLLVMValue p_param;
8142
ObPLDataType pl_type = s.get_variable(param_desc.at(i).out_idx_)->get_type();
8143
if (pl_type.is_composite_type() || pl_type.is_cursor_type()) {8144
if (param_desc.at(i).is_out()) {8145
// 对于INOUT参数, execute immediate复杂类型传递的是指针, 什么都不需要做; inner call场景, inout参数会入参会深拷，这里需要重新拷回
8146
// 对于OUT参数, 复杂类型构造了新的ObjParam, 这里进行COPY;
8147
if (PL_CALL == s.get_type() &&
8148
static_cast<const ObPLCallStmt *>(&s)->get_nocopy_params().count() > i &&
8149
OB_INVALID_INDEX != static_cast<const ObPLCallStmt *>(&s)->get_nocopy_params().at(i) &&
8150
!param_desc.at(i).is_pure_out()) {8151
// inner call nocopy的inout参数传递是指针, 无需重新拷贝
8153
ObLLVMValue into_address;
8154
ObLLVMValue allocator;
8155
ObLLVMValue src_datum;
8156
ObLLVMValue dest_datum;
8157
OZ (extract_objparam_from_context(
8158
get_vars().at(CTX_IDX), param_desc.at(i).out_idx_, into_address));
8159
if (pl_type.is_collection_type()) {8160
ObLLVMValue dest_collection;
8161
OZ (extract_extend_from_objparam(into_address, pl_type, dest_collection));
8162
OZ (extract_allocator_from_collection(dest_collection, allocator));
8164
OZ (generate_null(ObIntType, allocator));
8166
OZ (extract_obobj_ptr_from_objparam(into_address, dest_datum));
8167
OZ (extract_obobj_ptr_from_objparam(p_arg, src_datum));
8168
OZ (pl_type.generate_copy(*this,
8169
*(s.get_namespace()),
8173
s.get_block()->in_notfound(),
8174
s.get_block()->in_warning(),
8177
} else if (PL_CALL == s.get_type()) {8178
OZ (generate_destruct_obj(s, src_datum));
8179
} else if (PL_EXECUTE == s.get_type() && param_desc.at(i).is_pure_out()) {8180
OZ (generate_destruct_obj(s, src_datum));
8184
} else { //处理基础类型的出参8185
ObSEArray<ObLLVMValue, 4> args;
8186
ObLLVMValue result_idx;
8187
ObLLVMValue ret_err;
8188
ObLLVMValue p_result_obj;
8189
ObLLVMValue need_set;
8190
OZ (get_helper().get_int64(param_desc.at(i).out_idx_, result_idx));
8191
OZ (generate_new_objparam(p_result_obj));
8192
OZ (get_helper().get_int8(true, need_set));
8193
OZ (args.push_back(get_vars().at(CTX_IDX)));
8194
OZ (args.push_back(p_arg));
8195
OZ (args.push_back(result_idx));
8196
OZ (args.push_back(p_result_obj));
8197
OZ (args.push_back(need_set));
8198
OZ (get_helper().create_call(ObString("spi_convert_objparam"),8199
get_spi_service().spi_convert_objparam_,
8203
ret_err, s.get_stmt_id(), s.get_block()->in_notfound(), s.get_block()->in_warning()));
8204
OZ (extract_datum_from_objparam(p_result_obj, pl_type.get_obj_type(), result));
8205
OZ (get_helper().create_store(
8206
result, get_vars().at(param_desc.at(i).out_idx_ + USER_ARG_OFFSET)),
8207
param_desc.at(i).out_idx_);
8209
} else { // 处理外部变量(Sys Var/User Var or PKG Basic Variables or Subprogram Basic Variables)8210
const ObRawExpr *expr = NULL;
8211
CK (OB_NOT_NULL(expr = s.get_expr(param_desc.at(i).param_)));
8213
} else if (expr->is_sys_func_expr()) {8214
OZ (generate_set_variable(param_desc.at(i).param_,
8216
T_DEFAULT == expr->get_expr_type(),
8218
s.get_block()->in_notfound(),
8219
s.get_block()->in_warning()));
8220
} else if (expr->is_obj_access_expr()) {8221
ObLLVMValue address;
8222
ObLLVMValue src_datum;
8223
ObLLVMValue dest_datum;
8224
ObLLVMValue allocator;
8225
ObPLDataType final_type;
8226
const ObObjAccessRawExpr *obj_access = NULL;
8227
uint64_t package_id = OB_INVALID_ID;
8228
uint64_t var_idx = OB_INVALID_ID;
8229
CK (OB_NOT_NULL(obj_access = static_cast<const ObObjAccessRawExpr *>(expr)));
8231
&& ObObjAccessIdx::is_package_variable(obj_access->get_access_idxs())) {8232
OZ (ObObjAccessIdx::get_package_id(obj_access, package_id, &var_idx));
8234
OZ (generate_null(ObIntType, allocator));
8235
CK (OB_NOT_NULL(obj_access));
8236
OZ (generate_expr(param_desc.at(i).param_, s, OB_INVALID_INDEX, address));
8237
OZ (obj_access->get_final_type(final_type));
8238
OZ (generate_check_not_null(s, final_type.get_not_null(), p_arg));
8239
if (final_type.is_obj_type()) {8240
OZ (extract_datum_ptr_from_objparam(
8241
p_arg, obj_access->get_result_type().get_type(), src_datum));
8242
OZ (extract_extend_from_objparam(address, final_type, dest_datum));
8243
OZ (final_type.generate_copy(*this,
8244
*(s.get_namespace()),
8248
s.get_block()->in_notfound(),
8249
s.get_block()->in_warning(),
8252
OZ (extract_obobj_ptr_from_objparam(p_arg, src_datum));
8253
OZ (extract_obobj_ptr_from_objparam(address, dest_datum));
8254
OZ (final_type.generate_copy(*this,
8255
*(s.get_namespace()),
8259
s.get_block()->in_notfound(),
8260
s.get_block()->in_warning(),
8263
} else if (PL_CALL == s.get_type()) {8264
const ObPLCallStmt *call_stmt = static_cast<const ObPLCallStmt *>(&s);
8265
if (call_stmt->get_nocopy_params().count() > i &&
8266
OB_INVALID_INDEX != call_stmt->get_nocopy_params().at(i) &&
8267
!param_desc.at(i).is_pure_out()) {8268
// inner call nocopy的inout参数传递是指针, 无需释放
8270
OZ (generate_destruct_obj(s, src_datum));
8272
} else if (PL_EXECUTE == s.get_type() && param_desc.at(i).is_pure_out()) {8273
OZ (generate_destruct_obj(s, src_datum));
8276
if (OB_SUCC(ret) && package_id != OB_INVALID_ID && var_idx != OB_INVALID_ID) {8277
OZ (generate_update_package_changed_info(s, package_id, var_idx));
8280
ret = OB_ERR_UNEXPECTED;
8281
LOG_WARN("Invalid expr", K(i), K(*expr), K(ret));8287
int ObPLCodeGenerator::generate_out_params(
8288
const ObPLStmt &s, const ObIArray<InOutParam> ¶m_desc, ObLLVMValue ¶ms)
8290
int ret = OB_SUCCESS;
8291
ObSEArray<int64_t, 8> nocopy_params;
8292
if (PL_CALL == s.get_type()) {8293
const ObPLCallStmt *call_stmt = static_cast<const ObPLCallStmt*>(&s);
8294
OZ (nocopy_params.assign(call_stmt->get_nocopy_params()));
8295
CK (nocopy_params.count() == 0 || nocopy_params.count() == param_desc.count());
8298
for (int64_t i = 0; OB_SUCC(ret) && i < nocopy_params.count(); ++i) {8299
if (nocopy_params.at(i) != OB_INVALID_INDEX && param_desc.at(i).is_out()) {8300
OZ (generate_out_param(s, param_desc, params, i));
8304
for (int64_t i = 0; OB_SUCC(ret) && i < param_desc.count(); ++i) {8305
// 处理输出参数的情况, NoCopy参数已经处理过了, 处理非NoCopy的参数
8306
if (nocopy_params.count() > 0 && nocopy_params.at(i) != OB_INVALID_INDEX) {8308
} else if (param_desc.at(i).is_out()) {8309
OZ (generate_out_param(s, param_desc, params, i));
8315
int ObPLCodeGenerator::generate(ObPLPackage &pl_package)
8317
int ret = OB_SUCCESS;
8319
OZ (prepare_external());
8320
OZ (prepare_local_user_type());
8321
OZ (prepare_expression(pl_package));
8322
OZ (generate_obj_access_expr());
8326
LOG_INFO("================Original LLVM Module================", K(debug_mode_));8327
helper_.dump_module();
8329
OZ (helper_.verify_module(), pl_package);
8330
OX (helper_.compile_module(!debug_mode_));
8333
OZ (final_expression(pl_package));
8337
int ObPLCodeGenerator::generate(ObPLFunction &pl_func)
8339
int ret = OB_SUCCESS;
8340
ObPLFunctionAST &ast = static_cast<ObPLFunctionAST&>(ast_);
8342
|| !ast.get_is_all_sql_stmt()
8343
|| !ast_.get_obj_access_exprs().empty()) {8344
OZ (generate_normal(pl_func));
8346
OZ (generate_simple(pl_func));
8348
LOG_TRACE("generate pl function",8349
K(debug_mode_), K(ast.get_is_all_sql_stmt()), K(ast.get_obj_access_exprs().empty()));
8353
int ObPLCodeGenerator::generate_simple(ObPLFunction &pl_func)
8355
int ret = OB_SUCCESS;
8356
ObPLFunctionAST &ast = static_cast<ObPLFunctionAST&>(ast_);
8357
common::ObFixedArray<ObPLSqlInfo, common::ObIAllocator> &sql_infos = pl_func.get_sql_infos();
8359
CK (ast.get_is_all_sql_stmt());
8360
OZ (prepare_expression(pl_func));
8361
OZ (final_expression(pl_func));
8362
OZ (pl_func.set_variables(get_ast().get_symbol_table()));
8363
OZ (pl_func.get_dependency_table().assign(get_ast().get_dependency_table()));
8364
OX (pl_func.add_members(get_ast().get_flag()));
8365
OX (pl_func.set_pipelined(get_ast().get_pipelined()));
8366
OX (pl_func.set_action((uint64_t)(&ObPL::simple_execute)));
8367
OX (pl_func.set_can_cached(get_ast().get_can_cached()));
8368
OX (pl_func.set_is_all_sql_stmt(get_ast().get_is_all_sql_stmt()));
8369
OX (pl_func.set_has_parallel_affect_factor(get_ast().has_parallel_affect_factor()));
8371
OX (sql_infos.set_capacity(static_cast<uint32_t>(ast.get_sql_stmts().count())));
8372
for (int64_t i = 0; OB_SUCC(ret) && i < ast.get_sql_stmts().count(); ++i) {8373
const ObPLSqlStmt *sql_stmt = ast.get_sql_stmts().at(i);
8374
ObPLSqlInfo sql_info(pl_func.get_allocator());
8375
CK (OB_NOT_NULL(sql_stmt));
8376
OZ (sql_info.generate(*sql_stmt, pl_func.get_expressions()));
8377
OZ (sql_infos.push_back(sql_info));
8379
if (OB_SUCC(ret) && ObTriggerInfo::is_trigger_body_package_id(pl_func.get_package_id())) {8380
OZ (pl_func.set_types(get_ast().get_user_type_table()));
8386
int ObPLCodeGenerator::generate_normal(ObPLFunction &pl_func)
8388
int ret = OB_SUCCESS;
8391
OB_SUCC(ret) && i < get_ast().get_symbol_table().get_count() + USER_ARG_OFFSET + 1;
8393
ObLLVMValue dummy_value;
8394
if (OB_FAIL(vars_.push_back(dummy_value))) {8395
LOG_WARN("failed to push back dummy value", K(ret), K(i));8399
} else if (OB_FAIL(generate_prototype())) {8400
LOG_WARN("failed to generate a pointer", K(ret));8401
} else if (OB_FAIL(func_.set_personality(get_eh_service().eh_personality_))) {8402
LOG_WARN("failed to set_personality", K(ret));8403
} else if (OB_FAIL(helper_.create_block(ObString("entry"), func_, entry_))) {8404
LOG_WARN("failed to create block", K(ret));8405
} else if (OB_FAIL(helper_.create_block(ObString("exit"), func_, exit_))) {8406
LOG_WARN("failed to create block", K(ret));8407
} else if (OB_FAIL(set_current(entry_))) {8408
LOG_WARN("failed to set current", K(ret));8409
} else if (OB_FAIL(generate_di_prototype())) {8410
LOG_WARN("failed to generate di prototype", K(ret));8411
} else { /*do nothing*/ }8414
ObPLCodeGenerateVisitor visitor(*this);
8415
if (OB_ISNULL(get_ast().get_body())) {8416
ret = OB_ERR_UNEXPECTED;
8417
LOG_WARN("pl body is NULL", K(ret));8418
} else if (OB_FAIL(helper_.set_insert_point(entry_))) {8419
LOG_WARN("failed set_insert_point", K(ret));8420
} else if (OB_FAIL(set_debug_location(*get_ast().get_body()))) {8421
LOG_WARN("failed to set debug location", K(ret));8422
} else if (OB_FAIL(init_argument())) {8423
LOG_WARN("failed to init augument", K(ret));8424
} else if (OB_FAIL(prepare_external())) {8425
LOG_WARN("failed to prepare external", K(ret));8426
} else if (lib::is_oracle_mode() && OB_FAIL(prepare_local_user_type())) {8427
LOG_WARN("failed to prepare local user type", K(ret));8428
} else if (OB_FAIL(prepare_expression(pl_func))) {8429
LOG_WARN("failed to prepare expression", K(ret));8430
} else if (OB_FAIL(prepare_subprogram(pl_func))) {8431
LOG_WARN("failed to prepare subprogram", K(ret));8432
} else if (OB_FAIL(SMART_CALL(visitor.generate(*get_ast().get_body())))) {8433
LOG_WARN("failed to generate a pl body", K(ret));8438
if (get_ast().get_ret_type().is_obj_type()
8439
&& (OB_ISNULL(get_ast().get_ret_type().get_data_type())
8440
|| get_ast().get_ret_type().get_data_type()->get_meta_type().is_invalid())) {8441
ret = OB_ERR_UNEXPECTED;
8442
LOG_WARN("return type is invalid", K(func_), K(ret));8443
} else if (!current_.is_terminated()) { //如果当前block没有终止符，强制跳转8444
if (OB_FAIL(finish_current(exit_))) {8445
LOG_WARN("failed to finish_current", K(ret));8447
} else { /*do nothing*/ }8450
ObLLVMValue ret_value;
8451
if (OB_FAIL(helper_.set_insert_point(exit_))) {8452
LOG_WARN("failed to set_insert_point", K(ret));8453
} else if (OB_FAIL(helper_.create_load(ObString("load_ret"), vars_.at(RET_IDX), ret_value))) {8454
LOG_WARN("failed to create_load", K(ret));8455
} else if (OB_FAIL(helper_.create_ret(ret_value))) {8456
LOG_WARN("failed to create_ret", K(ret));8457
} else { /*do nothing*/ }8462
if (OB_FAIL(generate_obj_access_expr())) {8463
LOG_WARN("generate obj access expr failed", K(ret));8464
} else if (debug_mode_ && OB_FAIL(di_helper_.finalize())) {8465
LOG_WARN("failed to finalize", K(ret));8471
LOG_INFO("================Original================", K(pl_func), K(debug_mode_));8472
helper_.dump_module();
8474
OZ (helper_.verify_module(), pl_func);
8475
OX (helper_.compile_module(!debug_mode_));
8479
if (OB_FAIL(final_expression(pl_func))) {8480
LOG_WARN("generate obj access expr failed", K(ret));8481
} else if (OB_FAIL(pl_func.set_variables(get_ast().get_symbol_table()))) {8482
LOG_WARN("failed to set variables", K(get_ast().get_symbol_table()), K(ret));8483
} else if (OB_FAIL(pl_func.get_dependency_table().assign(get_ast().get_dependency_table()))) {8484
LOG_WARN("failed to set ref objects", K(get_ast().get_dependency_table()), K(ret));8485
} else if (OB_FAIL(pl_func.set_types(get_ast().get_user_type_table()))) {8486
LOG_WARN("failed to set types", K(ret));8488
pl_func.add_members(get_ast().get_flag());
8489
pl_func.set_pipelined(get_ast().get_pipelined());
8490
pl_func.set_action(helper_.get_function_address(get_ast().get_name()));
8491
pl_func.set_can_cached(get_ast().get_can_cached());
8492
pl_func.set_is_all_sql_stmt(get_ast().get_is_all_sql_stmt());
8493
pl_func.set_has_parallel_affect_factor(get_ast().has_parallel_affect_factor());
8497
OX (helper_.dump_debuginfo());
8498
OZ (pl_func.set_variables_debuginfo(get_ast().get_symbol_debuginfo_table()));
8499
OZ (pl_func.set_name_debuginfo(get_ast()));
8501
OX (helper_.final());
8502
debug_mode_ = false;
8506
int ObPLCodeGenerator::extract_meta_ptr_from_obj(ObLLVMValue &p_obj, ObLLVMValue &result)
8508
int ret = OB_SUCCESS;
8509
ObSEArray<int64_t, 2> indices;
8510
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(0))) {8511
LOG_WARN("push_back error", K(ret));8512
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"), p_obj,8513
indices, result))) {8514
LOG_WARN("failed to create gep", K(ret));8515
} else { /*do nothing*/ }8519
int ObPLCodeGenerator::extract_type_ptr_from_obj(ObLLVMValue &p_obj, ObLLVMValue &result)
8521
int ret = OB_SUCCESS;
8523
OZ (extract_meta_ptr_from_obj(p_obj, p_meta));
8524
OZ (helper_.create_gep(ObString("extract_type_pointer"), p_meta, 0, result));8528
int ObPLCodeGenerator::extract_meta_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8530
int ret = OB_SUCCESS;
8531
ObSEArray<int64_t, 3> indices;
8532
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(0))) {8533
LOG_WARN("push_back error", K(ret));8534
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"), p_objparam, indices, result))) {8535
LOG_WARN("failed to create gep", K(ret));8536
} else { /*do nothing*/ }8540
int ObPLCodeGenerator::extract_accuracy_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8542
int ret = OB_SUCCESS;
8543
ObSEArray<int64_t, 2> indices;
8544
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(1))) {8545
LOG_WARN("push_back error", K(ret));8546
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"), p_objparam, indices, result))) {8547
LOG_WARN("failed to create gep", K(ret));8548
} else { /*do nothing*/ }8552
int ObPLCodeGenerator::extract_param_flag_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8554
int ret = OB_SUCCESS;
8555
ObSEArray<int64_t, 2> indices;
8556
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(3))) {8557
LOG_WARN("push_back error", K(ret));8558
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"),8559
p_objparam, indices, result))) {8560
LOG_WARN("failed to create gep", K(ret));8561
} else { /*do nothing*/ }8565
int ObPLCodeGenerator::extract_raw_text_pos_ptr_from_objparam(ObLLVMValue &p_objparam,
8566
ObLLVMValue &result)
8568
int ret = OB_SUCCESS;
8569
ObSEArray<int64_t, 2> indices;
8570
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(4))) {8571
LOG_WARN("push_back error", K(ret));8572
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"),8573
p_objparam, indices, result))) {8574
LOG_WARN("failed to create gep", K(ret));8575
} else { /*do nothing*/ }8579
int ObPLCodeGenerator::extract_raw_text_len_ptr_from_objparam(ObLLVMValue &p_objparam,
8580
ObLLVMValue &result)
8582
int ret = OB_SUCCESS;
8583
ObSEArray<int64_t, 2> indices;
8584
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(5))) {8585
LOG_WARN("push_back error", K(ret));8586
} else if (OB_FAIL(helper_.create_gep(ObString("extract_meta_pointer"), p_objparam, indices, result))) {8587
LOG_WARN("failed to create gep", K(ret));8588
} else { /*do nothing*/ }8592
int ObPLCodeGenerator::extract_type_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8594
int ret = OB_SUCCESS;
8596
OZ (extract_meta_ptr_from_objparam(p_objparam, p_meta));
8597
OZ (helper_.create_gep(ObString("extract_type_pointer"), p_meta, 0, result));8601
int ObPLCodeGenerator::extract_cslevel_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8603
int ret = OB_SUCCESS;
8605
if (OB_FAIL(extract_meta_ptr_from_objparam(p_objparam, p_meta))) {8606
LOG_WARN("faled to extract_meta_ptr_from_objparam", K(ret));8607
} else if (OB_FAIL(helper_.create_gep(ObString("extract_scale_pointer"), p_meta, 1, result))) {8608
LOG_WARN("failed to create gep", K(ret));8609
} else { /*do nothing*/ }8613
int ObPLCodeGenerator::extract_cstype_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8615
int ret = OB_SUCCESS;
8617
if (OB_FAIL(extract_meta_ptr_from_objparam(p_objparam, p_meta))) {8618
LOG_WARN("faled to extract_meta_ptr_from_objparam", K(ret));8619
} else if (OB_FAIL(helper_.create_gep(ObString("extract_scale_pointer"), p_meta, 2, result))) {8620
LOG_WARN("failed to create gep", K(ret));8621
} else { /*do nothing*/ }8625
int ObPLCodeGenerator::extract_scale_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8627
int ret = OB_SUCCESS;
8629
if (OB_FAIL(extract_meta_ptr_from_objparam(p_objparam, p_meta))) {8630
LOG_WARN("faled to extract_meta_ptr_from_objparam", K(ret));8631
} else if (OB_FAIL(helper_.create_gep(ObString("extract_scale_pointer"), p_meta, 3, result))) {8632
LOG_WARN("failed to create gep", K(ret));8633
} else { /*do nothing*/ }8637
int ObPLCodeGenerator::extract_flag_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8639
int ret = OB_SUCCESS;
8641
if (OB_FAIL(extract_param_flag_ptr_from_objparam(p_objparam, p_meta))) {8642
LOG_WARN("faled to extract_meta_ptr_from_objparam", K(ret));8643
} else if (OB_FAIL(helper_.create_gep(ObString("extract_scale_pointer"), p_meta, 1, result))) {8644
LOG_WARN("failed to create gep", K(ret));8645
} else { /*do nothing*/ }8649
int ObPLCodeGenerator::extract_obobj_ptr_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8651
int ret = OB_SUCCESS;
8652
OZ (helper_.create_gep(ObString("extract_obj_pointer"), p_objparam, 0, result));8656
int ObPLCodeGenerator::extract_obobj_from_objparam(ObLLVMValue &p_objparam, ObLLVMValue &result)
8658
int ret = OB_SUCCESS;
8660
if (OB_FAIL(extract_obobj_ptr_from_objparam(p_objparam, p_obj))) {8661
LOG_WARN("failed to create gep", K(ret));8662
} else if (OB_FAIL(helper_.create_load(ObString("load_value"), p_obj, result))) {8663
LOG_WARN("failed to create load", K(ret));8664
} else { /*do nothing*/ }8668
int ObPLCodeGenerator::extract_datum_ptr_from_objparam(ObLLVMValue &p_objparam, ObObjType type, ObLLVMValue &result)
8671
int ret = OB_SUCCESS;
8672
ObLLVMValue datum_addr;
8673
ObLLVMType datum_type;
8674
ObLLVMType datum_pointer_type;
8675
/* if (ob_is_string_tc(type)
8676
|| ob_is_number_tc(type)
8677
|| ob_is_text_tc(type)
8678
|| ob_is_otimestampe_tc(type)
8679
|| ob_is_raw_tc(type)) {*/8680
ObSEArray<int64_t, 3> indices;
8681
if (OB_FAIL(indices.push_back(0)) || OB_FAIL(indices.push_back(0))) {8682
LOG_WARN("push_back error", K(ret));8683
} else if (OB_FAIL(helper_.create_gep(ObString("extract_int64_pointer"), p_objparam, indices, datum_addr))) {8684
LOG_WARN("failed to create gep", K(ret));8685
} else if (OB_FAIL(adt_service_.get_obj(datum_type))) {8686
LOG_WARN("failed to get argv type", K(ret));8687
} else if (OB_FAIL(datum_type.get_pointer_to(datum_pointer_type))) {8688
LOG_WARN("failed to get pointer to", K(ret));8689
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_addr_to_datum"), datum_addr, datum_pointer_type, result))) {8690
LOG_WARN("failed to create bit cast", K(ret));8691
} else { /*do nothing*/ }8693
if (OB_FAIL(extract_value_ptr_from_objparam(p_objparam, type, result))) {8694
LOG_WARN("failed to extract value from objparam", K(ret));8700
int ObPLCodeGenerator::cast_to_int64(ObLLVMValue &p_value)
8702
int ret = OB_SUCCESS;
8703
ObLLVMValue p_value_int64, value_int64, value;
8704
ObLLVMType llvm_type, pointer_type;
8705
OZ (helper_.get_llvm_type(ObIntType, llvm_type));
8706
OZ (llvm_type.get_pointer_to(pointer_type));
8707
OZ (helper_.create_load(ObString("load value"), p_value, value));8708
OZ (helper_.create_sext(ObString("sext to int64"), value, llvm_type, value_int64));8710
// OZ (generate_debug(ObString("after sext value to int64"), value_int64));8712
OZ (helper_.create_bit_cast(ObString("bitcast"), p_value, pointer_type, p_value_int64));8713
OZ (helper_.create_store(value_int64, p_value_int64));
8717
int ObPLCodeGenerator::extract_value_ptr_from_obj(ObLLVMValue &p_obj, ObObjType type, ObLLVMValue &result)
8719
int ret = OB_SUCCESS;
8720
ObLLVMValue p_obj_int64;
8721
ObLLVMType llvm_type;
8722
ObLLVMType pointer_type;
8723
if (OB_FAIL(helper_.create_gep(ObString("extract_int64_pointer"), p_obj, 2, p_obj_int64))) {8724
LOG_WARN("failed to create gep", K(ret));8728
ObLLVMValue false_value;
8729
OZ (helper_.get_llvm_type(ObTinyIntType, llvm_type));
8730
OZ (llvm_type.get_pointer_to(pointer_type));
8731
OZ (helper_.create_bit_cast(ObString("cast_int64_to_int8"), p_obj_int64, pointer_type, result));8732
OZ (helper_.get_int8(false, false_value));
8733
OZ (helper_.create_store(false_value, result));
8737
case ObUTinyIntType: {8738
if (OB_FAIL(helper_.get_llvm_type(ObTinyIntType, llvm_type))) {8739
LOG_WARN("failed to get pointer to", K(ret));8740
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8741
LOG_WARN("failed to get pointer to", K(ret));8742
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_int8"), p_obj_int64, pointer_type, result))) {8743
LOG_WARN("failed to create bit cast", K(ret));8744
} else { /*do nothing*/ }8747
case ObSmallIntType:
8748
case ObUSmallIntType: {8749
if (OB_FAIL(helper_.get_llvm_type(ObSmallIntType, llvm_type))) {8750
LOG_WARN("failed to get pointer to", K(ret));8751
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8752
LOG_WARN("failed to get pointer to", K(ret));8753
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_int16"), p_obj_int64, pointer_type, result))) {8754
LOG_WARN("failed to create bit cast", K(ret));8755
} else { /*do nothing*/ }8758
case ObMediumIntType:
8760
case ObUMediumIntType:
8761
case ObUInt32Type: {8762
if (OB_FAIL(helper_.get_llvm_type(ObInt32Type, llvm_type))) {8763
LOG_WARN("failed to get pointer to", K(ret));8764
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8765
LOG_WARN("failed to get pointer to", K(ret));8766
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_int32"), p_obj_int64, pointer_type, result))) {8767
LOG_WARN("failed to create bit cast", K(ret));8768
} else { /*do nothing*/ }8773
case ObDateTimeType:
8774
case ObTimestampType:
8781
result = p_obj_int64;
8785
case ObUFloatType: {8786
if (OB_FAIL(helper_.get_llvm_type(ObFloatType, llvm_type))) {8787
LOG_WARN("failed to get pointer to", K(ret));8788
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8789
LOG_WARN("failed to get pointer to", K(ret));8790
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_float"), p_obj_int64, pointer_type, result))) {8791
LOG_WARN("failed to create bit cast", K(ret));8792
} else { /*do nothing*/ }8796
case ObUDoubleType: {8797
if (OB_FAIL(helper_.get_llvm_type(ObDoubleType, llvm_type))) {8798
LOG_WARN("failed to get pointer to", K(ret));8799
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8800
LOG_WARN("failed to get pointer to", K(ret));8801
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_double"), p_obj_int64, pointer_type, result))) {8802
LOG_WARN("failed to create bit cast", K(ret));8803
} else { /*do nothing*/ }8808
case ObNumberFloatType: {8809
if (OB_FAIL(helper_.get_llvm_type(ObNumberType, llvm_type))) {8810
LOG_WARN("failed to get pointer to", K(ret));8811
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8812
LOG_WARN("failed to get pointer to", K(ret));8813
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_number"), p_obj_int64, pointer_type, result))) {8814
LOG_WARN("failed to create_bit_cast", K(ret));8815
} else { /*do nothing*/ }8818
case ObNVarchar2Type:
8822
case ObHexStringType:
8823
case ObURowIDType: {8824
if (OB_FAIL(helper_.get_llvm_type(ObCharType, llvm_type))) {8825
LOG_WARN("failed to get pointer to", K(ret));8826
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8827
LOG_WARN("failed to get pointer to", K(ret));8828
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_char"), p_obj_int64, pointer_type, result))) {8829
LOG_WARN("failed to create_bit_cast", K(ret));8830
} else { /*do nothing*/ }8833
case ObExtendType: {8834
if (OB_FAIL(helper_.get_llvm_type(ObExtendType, llvm_type))) {8835
LOG_WARN("failed to get pointer to", K(ret));8836
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8837
LOG_WARN("failed to get pointer to", K(ret));8838
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_extend"), p_obj_int64, pointer_type, result))) {8839
LOG_WARN("failed to create_bit_cast", K(ret));8840
} else { /*do nothing*/ }8843
case ObUnknownType: {8844
if (OB_FAIL(helper_.get_llvm_type(ObUnknownType, llvm_type))) {8845
LOG_WARN("failed to get pointer to", K(ret));8846
} else if (OB_FAIL(llvm_type.get_pointer_to(pointer_type))) {8847
LOG_WARN("failed to get pointer to", K(ret));8848
} else if (OB_FAIL(helper_.create_bit_cast(ObString("cast_int64_to_unknown"), p_obj_int64, pointer_type, result))) {8849
LOG_WARN("failed to create_bit_cast", K(ret));8850
} else { /*do nothing*/ }8853
case ObTimestampTZType:
8854
case ObTimestampLTZType:
8855
case ObTimestampNanoType://TODO: not support now, @yanhua
8856
case ObRawType: //TODO: not support now, @xiaofeng
8857
case ObIntervalYMType: //TODO: not support now, @jim.wjh
8858
case ObIntervalDSType: //TODO: not support now, @jim.wjh
8860
if (OB_FAIL(generate_null_pointer(ObIntType, result))) {8861
LOG_WARN("failed to get pointer to", K(ret));8870
int ObPLCodeGenerator::extract_value_from_obj(jit::ObLLVMValue &p_obj,
8872
jit::ObLLVMValue &result)
8874
int ret = OB_SUCCESS;
8875
ObLLVMValue result_ptr;
8876
OZ (extract_value_ptr_from_obj(p_obj, type, result_ptr));
8877
OZ (helper_.create_load(ObString("load_value"), result_ptr, result));8881
int ObPLCodeGenerator::extract_value_ptr_from_objparam(ObLLVMValue &p_objparam, ObObjType type, ObLLVMValue &result)
8883
int ret = OB_SUCCESS;
8885
if (OB_FAIL(helper_.create_gep(ObString("extract_obj_pointer"), p_objparam, 0, p_obj))) {8886
LOG_WARN("failed to create gep", K(ret));8887
} else if (OB_FAIL(extract_value_ptr_from_obj(p_obj, type, result))) {8888
LOG_WARN("failed to extract_value_ptr_from_obj", K(ret));8889
} else { /*do nothing*/ }8893
int ObPLCodeGenerator::extract_datum_from_objparam(ObLLVMValue &p_objparam, ObObjType type, ObLLVMValue &result)
8895
int ret = OB_SUCCESS;
8896
ObLLVMValue result_ptr;
8897
if (OB_FAIL(extract_datum_ptr_from_objparam(p_objparam, type, result_ptr))) {8898
LOG_WARN("failed to create gep", K(ret));8899
} else if (OB_FAIL(helper_.create_load(ObString("load_datum"), result_ptr, result))) {8900
LOG_WARN("failed to create load", K(ret));8901
} else { /*do nothing*/ }8905
int ObPLCodeGenerator::extract_value_from_objparam(ObLLVMValue &p_objparam, ObObjType type, ObLLVMValue &result)
8907
int ret = OB_SUCCESS;
8908
ObLLVMValue result_ptr;
8909
if (OB_FAIL(extract_value_ptr_from_objparam(p_objparam, type, result_ptr))) {8910
LOG_WARN("failed to create gep", K(ret));8911
} else if (OB_FAIL(helper_.create_load(ObString("load_value"), result_ptr, result))) {8912
LOG_WARN("failed to create load", K(ret));8913
} else { /*do nothing*/ }8917
int ObPLCodeGenerator::extract_extend_from_objparam(ObLLVMValue &p_objparam, const ObPLDataType &type, ObLLVMValue &result)
8919
int ret = OB_SUCCESS;
8921
ObLLVMType llvm_type;
8922
ObLLVMType addr_type;
8923
if (OB_FAIL(extract_value_from_objparam(p_objparam, ObExtendType, extend))) {8924
LOG_WARN("failed to extract_value_from_objparam", K(ret));8925
} else if (OB_FAIL(get_llvm_type(type, llvm_type))) {8926
LOG_WARN("failed to get_llvm_type", K(ret));8927
} else if (OB_FAIL(llvm_type.get_pointer_to(addr_type))) {8928
LOG_WARN("failed to get_llvm_type", K(ret));8929
} else if (OB_FAIL(helper_.create_int_to_ptr(ObString("cast_extend_to_ptr"), extend, addr_type, result))) {8930
LOG_WARN("failed to create_bit_cast", K(ret));8931
} else { /*do nothing*/ }8935
int ObPLCodeGenerator::extract_extend_from_obj(ObLLVMValue &p_obj,
8936
const ObPLDataType &type,
8937
ObLLVMValue &result)
8939
int ret = OB_SUCCESS;
8941
ObLLVMType llvm_type;
8942
ObLLVMType addr_type;
8943
if (OB_FAIL(extract_value_from_obj(p_obj, ObExtendType, extend))) {8944
LOG_WARN("failed to extract_value_from_objparam", K(ret));8945
} else if (OB_FAIL(get_llvm_type(type, llvm_type))) {8946
LOG_WARN("failed to get_llvm_type", K(ret));8947
} else if (OB_FAIL(llvm_type.get_pointer_to(addr_type))) {8948
LOG_WARN("failed to get_llvm_type", K(ret));8949
} else if (OB_FAIL(helper_.create_int_to_ptr(ObString("cast_extend_to_ptr"),8953
LOG_WARN("failed to create_bit_cast", K(ret));8954
} else { /*do nothing*/ }8958
int ObPLCodeGenerator::extract_obj_ptr_from_result(jit::ObLLVMValue &p_objparam,
8959
jit::ObLLVMValue &result)
8961
int ret = OB_SUCCESS;
8963
ObLLVMType obj_type;
8964
ObLLVMType p_obj_type;
8965
OZ (extract_value_from_obj(p_objparam, ObExtendType, extend));
8966
OZ (adt_service_.get_obj(obj_type));
8967
OZ (obj_type.get_pointer_to(p_obj_type));
8968
OZ (helper_.create_int_to_ptr(ObString("cast_extend_to_obj_ptr"), extend, p_obj_type, result));8972
int ObPLCodeGenerator::extract_objparam_from_store(ObLLVMValue &p_param_store, const int64_t idx, ObLLVMValue &result)
8974
int ret = OB_SUCCESS;
8975
const static int64_t BlocksIDX = 3;
8976
const static int64_t SEArrayDataIDX = 1;
8977
ObLLVMValue param_store;
8979
ObLLVMValue p_blocks_carray;
8980
ObLLVMValue p_obj_block;
8981
ObLLVMValue obj_block;
8982
ObLLVMValue p_obj_param;
8983
ObLLVMValue result_tmp_p;
8984
ObLLVMType obj_param_type;
8985
ObLLVMType p_obj_param_type;
8986
ObArray<int64_t> extract_obj_param_idxes;
8987
ObArray<int64_t> extract_block_addr_idxes;
8989
if (OB_FAIL(helper_.create_load(ObString("load_param_store"),8992
LOG_WARN("failed to create load", K(ret));8993
} else if (OB_FAIL(helper_.create_extract_value(ObString("extract_blocks"),8994
param_store, BlocksIDX,
8996
LOG_WARN("failed to create extract value", K(ret));8997
} else if (OB_FAIL(helper_.create_extract_value(ObString("extract_blocks_pointer"),8998
blocks, SEArrayDataIDX,
8999
p_blocks_carray))) {9000
LOG_WARN("failed to create extract value", K(ret));9002
const int64_t block_obj_num = ParamStore::BLOCK_CAPACITY;
9003
const int64_t block_idx = idx / block_obj_num;
9004
const int64_t obj_in_block_idx = idx % block_obj_num;
9005
if (OB_FAIL(extract_block_addr_idxes.push_back(block_idx))
9006
|| OB_FAIL(extract_block_addr_idxes.push_back(0))) {9007
LOG_WARN("failed to push back element", K(ret));9008
} else if (OB_FAIL(helper_.create_gep(ObString("extract_block_pointer"),9010
extract_block_addr_idxes, p_obj_block))) {9011
LOG_WARN("failed to create gep", K(ret));9012
} else if (OB_FAIL(helper_.create_load(ObString("load_obj_block"),9013
p_obj_block, obj_block))) {9014
LOG_WARN("failed to create_load", K(ret));9015
} else if (OB_FAIL(adt_service_.get_objparam(obj_param_type))) {9016
LOG_WARN("failed to get_objparam", K(ret));9017
} else if (OB_FAIL(obj_param_type.get_pointer_to(p_obj_param_type))) {9018
LOG_WARN("failed to get_pointer_to", K(ret));9019
} else if (OB_FAIL(helper_.create_int_to_ptr(ObString("cast_block_to_objparam_p"),9021
p_obj_param_type, p_obj_param))) {9022
LOG_WARN("failed to create_int_to_ptr cast", K(ret));9023
} else if (OB_FAIL(extract_obj_param_idxes.push_back(obj_in_block_idx))
9024
|| OB_FAIL(extract_obj_param_idxes.push_back(0))) {9025
LOG_WARN("failed to push back element", K(ret));9026
} else if (OB_FAIL(helper_.create_gep(ObString("extract_objparam"),9028
extract_obj_param_idxes,
9030
LOG_WARN("failed to create gep", K(ret));9031
} else if (OB_FAIL(helper_.create_bit_cast(ObString("bitcast"),9032
result_tmp_p, p_obj_param_type, result))) {9033
LOG_WARN("failed to cast obj pointer to objparam pointer", K(ret));9039
#define DEFINE_EXTRACT_CONTEXT_ELEM(item, idx) \
9040
int ObPLCodeGenerator::extract_##item##_from_context(jit::ObLLVMValue &p_pl_exex_ctx, jit::ObLLVMValue &result) \
9042
int ret = OB_SUCCESS; \
9043
ObLLVMValue pl_exex_ctx; \
9044
OZ (helper_.create_load(ObString("load_pl_exex_ctx"), p_pl_exex_ctx, pl_exex_ctx)); \9045
OZ (helper_.create_extract_value(ObString("extract_"#item), pl_exex_ctx, idx, result)); \9049
DEFINE_EXTRACT_CONTEXT_ELEM(allocator, IDX_PLEXECCTX_ALLOCATOR)
9050
DEFINE_EXTRACT_CONTEXT_ELEM(param_store, IDX_PLEXECCTX_PARAMS)
9051
DEFINE_EXTRACT_CONTEXT_ELEM(result, IDX_PLEXECCTX_RESULT)
9052
DEFINE_EXTRACT_CONTEXT_ELEM(status, IDX_PLEXECCTX_STATUS)
9053
DEFINE_EXTRACT_CONTEXT_ELEM(pl_ctx, IDX_PLEXECCTX_PL_CTX)
9054
DEFINE_EXTRACT_CONTEXT_ELEM(pl_function, IDX_PLEXECCTX_FUNC)
9056
int ObPLCodeGenerator::extract_objparam_from_context(ObLLVMValue &p_pl_exex_ctx, int64_t idx, ObLLVMValue &result)
9058
int ret = OB_SUCCESS;
9059
ObLLVMValue p_param_store;
9060
if (OB_FAIL(extract_param_store_from_context(p_pl_exex_ctx, p_param_store))) {9061
LOG_WARN("failed to extract_param_store_from_context", K(ret));9062
} else if (OB_FAIL(extract_objparam_from_store(p_param_store, idx, result))) {9063
LOG_WARN("failed to extract_objparam_from_store", K(ret));9064
} else { /*do nothing*/ }9068
int ObPLCodeGenerator::extract_value_from_context(ObLLVMValue &p_pl_exex_ctx, int64_t idx, ObObjType type, ObLLVMValue &result)
9070
int ret = OB_SUCCESS;
9071
ObLLVMValue p_objparam;
9072
if (OB_FAIL(extract_objparam_from_context(p_pl_exex_ctx, idx, p_objparam))) {9073
LOG_WARN("failed to extract_param_store_from_context", K(ret));9074
} else if (OB_FAIL(extract_value_from_objparam(p_objparam, type, result))) {9075
LOG_WARN("failed to extract_objparam_from_store", K(ret));9076
} else { /*do nothing*/ }9080
int ObPLCodeGenerator::extract_datum_from_context(ObLLVMValue &p_pl_exex_ctx, int64_t idx, ObObjType type, ObLLVMValue &result)
9082
int ret = OB_SUCCESS;
9083
ObLLVMValue p_objparam;
9084
if (OB_FAIL(extract_objparam_from_context(p_pl_exex_ctx, idx, p_objparam))) {9085
LOG_WARN("failed to extract_param_store_from_context", K(ret));9086
} else if (OB_FAIL(extract_datum_from_objparam(p_objparam, type, result))) {9087
LOG_WARN("failed to extract_objparam_from_store", K(ret));9088
} else { /*do nothing*/ }9092
int ObPLCodeGenerator::extract_arg_from_argv(ObLLVMValue &p_argv, int64_t idx, ObLLVMValue &result)
9094
return helper_.create_gep(ObString("extract_arg"), p_argv, idx, result);9097
int ObPLCodeGenerator::extract_objparam_from_argv(jit::ObLLVMValue &p_argv,
9099
jit::ObLLVMValue &result)
9101
int ret = OB_SUCCESS;
9104
ObLLVMType objparam;
9105
ObLLVMType pointer_type;
9106
if (OB_FAIL(extract_arg_from_argv(p_argv, idx, pp_arg))) {9107
LOG_WARN("failed to create load", K(ret));9108
} else if (OB_FAIL(helper_.create_load(ObString("load_arg"), pp_arg, p_arg))) {9109
LOG_WARN("failed to create load", K(ret));9110
} else if (OB_FAIL(adt_service_.get_objparam(objparam))) {9111
LOG_WARN("failed to get argv type", K(ret));9112
} else if (OB_FAIL(objparam.get_pointer_to(pointer_type))) {9113
LOG_WARN("failed to get pointer to", K(ret));9114
} else if (OB_FAIL(helper_.create_int_to_ptr(ObString("cast_arg_to_pointer"), p_arg,9115
pointer_type, result))) {9116
LOG_WARN("failed to create bit cast", K(ret));9117
} else { /*do nothing*/ }9121
int ObPLCodeGenerator::extract_datum_from_argv(ObLLVMValue &p_argv,
9124
ObLLVMValue &result)
9126
int ret = OB_SUCCESS;
9127
ObLLVMValue p_objparam;
9128
if (OB_FAIL(extract_objparam_from_argv(p_argv, idx, p_objparam))) {9129
LOG_WARN("failed to create load", K(ret));9130
} else if (OB_FAIL(extract_datum_from_objparam(p_objparam, type, result))) {9131
LOG_WARN("push_back error", K(ret));9132
} else { /*do nothing*/ }9136
int ObPLCodeGenerator::extract_value_from_argv(ObLLVMValue &p_argv, const int64_t idx, ObObjType type, ObLLVMValue &result)
9138
int ret = OB_SUCCESS;
9141
ObLLVMValue p_objparam;
9142
ObLLVMType objparam;
9143
ObLLVMType pointer_type;
9144
if (OB_FAIL(extract_objparam_from_argv(p_argv, idx, p_objparam))) {9145
LOG_WARN("failed to create load", K(ret));9146
} else if (OB_FAIL(extract_value_from_objparam(p_objparam, type, result))) {9147
LOG_WARN("push_back error", K(ret));9148
} else { /*do nothing*/ }9152
int ObPLCodeGenerator::extract_notnull_from_record(jit::ObLLVMValue &p_record, int64_t idx,
9153
jit::ObLLVMValue &result)
9155
int ret = OB_SUCCESS;
9156
ObLLVMValue p_result;
9157
OZ (extract_notnull_ptr_from_record(p_record, idx, p_result));
9158
OZ (helper_.create_load(ObString("load_record_elem"), p_result, result));9162
int ObPLCodeGenerator::extract_notnull_ptr_from_record(jit::ObLLVMValue &p_record,
9164
jit::ObLLVMValue &result)
9166
int ret = OB_SUCCESS;
9167
return helper_.create_gep(ObString("extract_record_elem"),9169
RECORD_META_OFFSET + idx,
9173
int ObPLCodeGenerator::extract_meta_from_record(jit::ObLLVMValue &p_record,
9176
jit::ObLLVMValue &result)
9178
int ret = OB_SUCCESS;
9179
ObLLVMValue p_result;
9180
OZ (extract_meta_ptr_from_record(p_record, member_cnt, idx, p_result));
9181
OZ (helper_.create_load(ObString("load_record_elem"), p_result, result));9185
int ObPLCodeGenerator::extract_meta_ptr_from_record(jit::ObLLVMValue &p_record,
9188
jit::ObLLVMValue &result)
9190
int ret = OB_SUCCESS;
9191
return helper_.create_gep(ObString("extract_record_elem"),9193
RECORD_META_OFFSET + member_cnt + idx,
9197
int ObPLCodeGenerator::extract_element_from_record(jit::ObLLVMValue &p_record,
9200
jit::ObLLVMValue &result)
9202
int ret = OB_SUCCESS;
9203
ObLLVMValue p_result;
9204
OZ (extract_element_ptr_from_record(p_record, member_cnt, idx, p_result));
9205
OZ (helper_.create_load(ObString("load_record_elem"), p_result, result));9209
int ObPLCodeGenerator::extract_element_ptr_from_record(jit::ObLLVMValue &p_record,
9212
jit::ObLLVMValue &result)
9214
int ret = OB_SUCCESS;
9215
return helper_.create_gep(ObString("extract_record_elem"),9217
RECORD_META_OFFSET + member_cnt + member_cnt + idx,
9221
#define DEFINE_EXTRACT_PTR_FROM_STRUCT(item, s, idx) \
9222
int ObPLCodeGenerator::extract_##item##_ptr_from_##s(jit::ObLLVMValue &p_struct, jit::ObLLVMValue &result) \
9224
return helper_.create_gep(ObString("extract_"#item), p_struct, idx, result); \9227
#define DEFINE_EXTRACT_VALUE_FROM_STRUCT(item, s) \
9228
int ObPLCodeGenerator::extract_##item##_from_##s(jit::ObLLVMValue &p_struct, jit::ObLLVMValue &result) \
9230
int ret = OB_SUCCESS; \
9231
ObLLVMValue p_result; \
9232
OZ (extract_##item##_ptr_from_##s(p_struct, p_result)); \
9233
OZ (helper_.create_load(ObString("load_"#item), p_result, result)); \9237
DEFINE_EXTRACT_PTR_FROM_STRUCT(type, condition_value, IDX_CONDITION_TYPE)
9238
DEFINE_EXTRACT_PTR_FROM_STRUCT(code, condition_value, IDX_CONDITION_CODE)
9239
DEFINE_EXTRACT_PTR_FROM_STRUCT(name, condition_value, IDX_CONDITION_STATE)
9240
DEFINE_EXTRACT_PTR_FROM_STRUCT(len, condition_value, IDX_CONDITION_LEN)
9241
DEFINE_EXTRACT_PTR_FROM_STRUCT(stmt, condition_value, IDX_CONDITION_STMT)
9242
DEFINE_EXTRACT_PTR_FROM_STRUCT(signal, condition_value, IDX_CONDITION_SIGNAL)
9244
DEFINE_EXTRACT_VALUE_FROM_STRUCT(type, condition_value)
9245
DEFINE_EXTRACT_VALUE_FROM_STRUCT(code, condition_value)
9246
DEFINE_EXTRACT_VALUE_FROM_STRUCT(name, condition_value)
9247
DEFINE_EXTRACT_VALUE_FROM_STRUCT(len, condition_value)
9248
DEFINE_EXTRACT_VALUE_FROM_STRUCT(stmt, condition_value)
9249
DEFINE_EXTRACT_VALUE_FROM_STRUCT(signal, condition_value)
9252
DEFINE_EXTRACT_PTR_FROM_STRUCT(type, collection, IDX_COLLECTION_TYPE)
9253
DEFINE_EXTRACT_PTR_FROM_STRUCT(id, collection, IDX_COLLECTION_ID)
9254
DEFINE_EXTRACT_PTR_FROM_STRUCT(isnull, collection, IDX_COLLECTION_ISNULL)
9255
DEFINE_EXTRACT_PTR_FROM_STRUCT(allocator, collection, IDX_COLLECTION_ALLOCATOR)
9256
DEFINE_EXTRACT_PTR_FROM_STRUCT(element, collection, IDX_COLLECTION_ELEMENT)
9257
DEFINE_EXTRACT_PTR_FROM_STRUCT(count, collection, IDX_COLLECTION_COUNT)
9258
DEFINE_EXTRACT_PTR_FROM_STRUCT(first, collection, IDX_COLLECTION_FIRST)
9259
DEFINE_EXTRACT_PTR_FROM_STRUCT(last, collection, IDX_COLLECTION_LAST)
9260
DEFINE_EXTRACT_PTR_FROM_STRUCT(data, collection, IDX_COLLECTION_DATA)
9262
DEFINE_EXTRACT_VALUE_FROM_STRUCT(type, collection)
9263
DEFINE_EXTRACT_VALUE_FROM_STRUCT(id, collection)
9264
DEFINE_EXTRACT_VALUE_FROM_STRUCT(isnull, collection)
9265
DEFINE_EXTRACT_VALUE_FROM_STRUCT(allocator, collection)
9266
DEFINE_EXTRACT_VALUE_FROM_STRUCT(element, collection)
9267
DEFINE_EXTRACT_VALUE_FROM_STRUCT(count, collection)
9268
DEFINE_EXTRACT_VALUE_FROM_STRUCT(first, collection)
9269
DEFINE_EXTRACT_VALUE_FROM_STRUCT(last, collection)
9270
DEFINE_EXTRACT_VALUE_FROM_STRUCT(data, collection)
9272
DEFINE_EXTRACT_PTR_FROM_STRUCT(capacity, varray, IDX_VARRAY_CAPACITY)
9273
DEFINE_EXTRACT_VALUE_FROM_STRUCT(capacity, varray)
9275
DEFINE_EXTRACT_PTR_FROM_STRUCT(type, record, IDX_RECORD_TYPE)
9276
DEFINE_EXTRACT_PTR_FROM_STRUCT(id, record, IDX_RECORD_ID)
9277
DEFINE_EXTRACT_PTR_FROM_STRUCT(isnull, record, IDX_RECORD_ISNULL)
9278
DEFINE_EXTRACT_PTR_FROM_STRUCT(count, record, IDX_RECORD_COUNT)
9279
DEFINE_EXTRACT_VALUE_FROM_STRUCT(type, record)
9280
DEFINE_EXTRACT_VALUE_FROM_STRUCT(id, record)
9281
DEFINE_EXTRACT_VALUE_FROM_STRUCT(isnull, record)
9282
DEFINE_EXTRACT_VALUE_FROM_STRUCT(count, record)
9284
DEFINE_EXTRACT_PTR_FROM_STRUCT(type, elemdesc, IDX_ELEMDESC_TYPE)
9285
DEFINE_EXTRACT_PTR_FROM_STRUCT(notnull, elemdesc, IDX_ELEMDESC_NOTNULL)
9286
DEFINE_EXTRACT_PTR_FROM_STRUCT(field_count, elemdesc, IDX_ELEMDESC_FIELD_COUNT)
9287
DEFINE_EXTRACT_VALUE_FROM_STRUCT(type, elemdesc)
9288
DEFINE_EXTRACT_VALUE_FROM_STRUCT(notnull, elemdesc)
9289
DEFINE_EXTRACT_VALUE_FROM_STRUCT(field_count, elemdesc)
9292
DEFINE_EXTRACT_VALUE_FROM_STRUCT(notnull, collection)
9294
int ObPLCodeGenerator::extract_notnull_ptr_from_collection(jit::ObLLVMValue &p_collection,
9295
jit::ObLLVMValue &result)
9297
int ret = OB_SUCCESS;
9298
ObLLVMValue p_element;
9299
OZ (extract_element_ptr_from_collection(p_collection, p_element));
9300
OZ (extract_notnull_ptr_from_elemdesc(p_element, result));
9304
DEFINE_EXTRACT_VALUE_FROM_STRUCT(field_count, collection)
9306
int ObPLCodeGenerator::extract_field_count_ptr_from_collection(jit::ObLLVMValue &p_collection,
9307
jit::ObLLVMValue &result)
9309
int ret = OB_SUCCESS;
9310
ObLLVMValue p_element;
9311
OZ (extract_element_ptr_from_collection(p_collection, p_element));
9312
OZ (extract_field_count_ptr_from_elemdesc(p_element, result));
9316
int ObPLCodeGenerator::generate_handle_ref_cursor(const ObPLCursor *cursor, const ObPLStmt &s,
9317
bool is_notfound, bool in_warning)
9319
int ret = OB_SUCCESS;
9320
CK (OB_NOT_NULL(cursor));
9321
// 以下一些情况不要关闭cursor:
9322
// function (cur out sys_refcursor), out类型参数
9323
// dup cursor 没有被init，所以不需要关闭，见generate_declare_cursor
9324
// 直接使用subprog 外部的cursor(不是ref cursor)，也不要关闭，例如
9327
CURSOR c (job VARCHAR2, max_sal NUMBER) IS
9328
SELECT employee_name, (salary - max_sal) overpayment FROM emp4 WHERE
9329
job_id = job AND salary > max_sal ORDER BY salary;
9330
PROCEDURE print_overpaid IS
9331
employee_name_ emp4.employee_name%TYPE;
9332
overpayment_ emp4.salary%TYPE;
9335
FETCH c INTO employee_name_, overpayment_; //这儿直接使用了外部cursor
9336
EXIT WHEN c%NOTFOUND;
9337
DBMS_OUTPUT.PUT_LINE(employee_name_ || ' (by ' || overpayment_ || ')');
9338
INSERT INTO test2 VALUES(employee_name_, TO_CHAR(overpayment_));
9342
bool is_pkg_cursor = false;
9344
// 定义在package spec中的才是package id，这种cursor的routine id是无效的
9345
// 有些定义在package函数中的cursor，它的package id也是有效的，routine id也是有效的。
9346
is_pkg_cursor = OB_INVALID_ID != cursor->get_package_id()
9347
&& OB_INVALID_ID == cursor->get_routine_id();
9349
OX (LOG_DEBUG("generate handle ref cursor", K(cursor->get_state()), K(is_pkg_cursor),9350
K(cursor->get_package_id()), K(cursor->get_routine_id()),K(*cursor)));
9351
if (OB_SUCC(ret) && (pl::ObPLCursor::CursorState::PASSED_IN != cursor->get_state()
9352
&& pl::ObPLCursor::CursorState::DUP_DECL != cursor->get_state()
9354
&& cursor->get_routine_id() == s.get_namespace()->get_routine_id()) {9358
ObLLVMValue line_num;
9359
OZ (get_helper().get_int64(s.get_stmt_id(), line_num));
9360
OZ (generate_debug(ObString("close cursor line number"), line_num));9363
ObSEArray<ObLLVMValue, 6> args;
9364
ObLLVMValue ret_err;
9365
ObLLVMValue arg_value;
9366
OZ (args.push_back(get_vars().at(CTX_IDX)));
9367
OZ (get_helper().get_int64(cursor->get_package_id(), arg_value));
9368
OZ (args.push_back(arg_value));
9369
OZ (get_helper().get_int64(cursor->get_routine_id(), arg_value));
9370
OZ (args.push_back(arg_value));
9371
OZ (get_helper().get_int64(cursor->get_index(), arg_value));
9372
OZ (args.push_back(arg_value));
9373
OZ (get_helper().get_int64(-1, arg_value));
9374
OZ (args.push_back(arg_value));
9375
OZ (get_helper().create_call(ObString("spi_handle_ref_cursor_ref_count"),9376
get_spi_service().spi_handle_ref_cursor_refcount_,
9378
OZ (check_success(ret_err, s.get_stmt_id(), is_notfound, in_warning));
9383
int ObPLCodeGenerator::restart_cg_when_goto_dest(const ObPLStmt &stmt)
9385
int ret = OB_SUCCESS;
9386
if (OB_NOT_NULL(get_current().get_v())) {9388
} else if (stmt.get_is_goto_dst()) {9389
ObLLVMBasicBlock goto_dst_blk;
9390
OZ (get_helper().create_block(ObString("restart_goto_block"), get_func(), goto_dst_blk));9391
OZ (set_current(goto_dst_blk));