oceanbase

1
/**
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.
11
 */
12

13
#define USING_LOG_PREFIX PL
14

15
#include "lib/worker.h"
16
#include "pl/ob_pl_resolver.h"
17
#include "pl/ob_pl_stmt.h"
18
#include "pl/ob_pl_router.h"
19
#include "common/sql_mode/ob_sql_mode_utils.h"
20
#include "pl/ob_pl_package.h"
21
#include "pl/parser/parse_stmt_item_type.h"
22
#include "pl/ob_pl_exception_handling.h"
23
#include "pl/ob_pl_interface_pragma.h"
24
#include "sql/parser/ob_parser.h"
25
#include "sql/parser/parse_malloc.h"
26
#include "sql/resolver/expr/ob_raw_expr_util.h"
27
#include "sql/printer/ob_raw_expr_printer.h"
28
#include "sql/resolver/ob_resolver_utils.h"
29
#include "sql/resolver/ddl/ob_ddl_resolver.h"
30
#include "sql/resolver/expr/ob_raw_expr_resolver_impl.h"
31
#include "sql/resolver/dml/ob_select_resolver.h"
32
#include "sql/resolver/expr/ob_raw_expr_wrap_enum_set.h"
33
#include "observer/ob_server_struct.h"
34
#include "sql/rewrite/ob_transform_pre_process.h"
35
#include "share/schema/ob_trigger_info.h"
36
#include "sql/resolver/expr/ob_raw_expr_copier.h"
37
#ifdef OB_BUILD_ORACLE_PL
38
#include "pl/ob_pl_warning.h"
39
#include "pl/ob_pl_udt_object_manager.h"
40
#include "pl/sys_package/ob_json_pl_utils.h"
41
#include "pl/dblink/ob_pl_dblink_util.h"
42
#endif
43
namespace oceanbase
44
{
45
using namespace common;
46
using namespace share;
47
using namespace sql;
48
using namespace share::schema;
49

50
namespace pl
51
{
52

53
const char *ObPLResolver::ANONYMOUS_BLOCK   = "__anonymous_block__";
54
const char *ObPLResolver::ANONYMOUS_ARG     = "__anonymous_argument__";
55
const char *ObPLResolver::ANONYMOUS_SQL_ARG = "__anonymous_argument__for_static_sql__";
56
const char *ObPLResolver::ANONYMOUS_INOUT_ARG  = "__anonymous_argument__for_inout__";
57

58
int ObPLResolver::init(ObPLFunctionAST &func_ast)
59
{
60
  int ret = OB_SUCCESS;
61
  if (OB_FAIL(make_block(func_ast, NULL, current_block_, true))) {
62
    LOG_WARN("failed to make block", K(current_block_), K(ret));
63
  } else {
64
    current_level_ = 0;
65
    func_ast.set_body(current_block_);
66
    arg_cnt_ = func_ast.get_arg_count();
67
    question_mark_cnt_ = 0;
68
    external_ns_.set_dependency_table(&func_ast.get_dependency_table());
69
    if (!OB_ISNULL(external_ns_.get_parent_ns())) {
70
      uint64_t type_start_gen_id = external_ns_.get_parent_ns()->get_type_table()->get_type_start_gen_id();
71
      func_ast.get_user_type_table().set_type_start_gen_id(type_start_gen_id);
72
    }
73
    if (OB_SUCC(ret) && lib::is_oracle_mode() && !func_ast.is_udt_cons()) {
74
      OZ (current_block_->get_namespace().add_label(
75
        func_ast.get_name(), ObPLLabelTable::ObPLLabelType::LABEL_BLOCK, NULL));
76
    }
77
    if (OB_SUCC(ret)) {
78
      if (!resolve_ctx_.package_guard_.is_inited()) {
79
        if (OB_FAIL(resolve_ctx_.package_guard_.init())) {
80
          LOG_WARN("package guard init failed", K(ret));
81
        }
82
      }
83
    }
84
    for (int64_t i = 0; OB_SUCC(ret) && i < func_ast.get_arg_count(); ++i) {
85
      if (OB_FAIL(current_block_->get_namespace().get_symbols().push_back(i))) {
86
        LOG_WARN("failed to add variable to symbol table", K(i),K(ret));
87
      } else {
88
        common::ObString name;
89
        ObPLDataType type;
90
        OZ (func_ast.get_argument(i, name, type));
91
        if (OB_SUCC(ret) && type.is_cursor_type()) {
92
          OZ (current_block_->get_namespace().get_cursors().push_back(
93
              current_block_->get_namespace().get_cursors().count()));
94
        }
95
        if (OB_SUCC(ret) && type.is_composite_type()) { // 将参数中的复杂类型在本ns中展开, 避免参数类型在符号表中不全
96
          if (type.is_local_type()
97
              && STANDALONE_ANONYMOUS == func_ast.get_proc_type()) {
98
            OZ (current_block_->get_namespace().get_types().push_back(
99
                current_block_->get_namespace().get_types().count()));
100
          } else {
101
            const ObUserDefinedType *user_type = NULL;
102
            OZ (current_block_->get_namespace().get_pl_data_type_by_id(type.get_user_type_id(), user_type), type, i);
103
            CK (OB_NOT_NULL(user_type));
104
            OZ (user_type->get_all_depended_user_type(resolve_ctx_, current_block_->get_namespace()), user_type);
105
          }
106
        }
107
      }
108
    }
109
    if (func_ast.is_function()) {
110
      const ObPLDataType &type = func_ast.get_ret_type();
111
      if (type.is_composite_type()) {
112
        const ObUserDefinedType *user_type = NULL;
113
        OZ (current_block_->get_namespace().get_pl_data_type_by_id(type.get_user_type_id(), user_type), type);
114
        CK (OB_NOT_NULL(user_type));
115
        OZ (user_type->get_all_depended_user_type(resolve_ctx_, current_block_->get_namespace()), user_type);
116
      }
117

118
    }
119
  }
120
  return ret;
121
}
122

123
int ObPLResolver::init_default_exprs(
124
  ObPLFunctionAST &func, const ObIArray<share::schema::ObRoutineParam *> &params)
125
{
126
  int ret = OB_SUCCESS;
127
  for (int64_t i = 0, idx = 0; OB_SUCC(ret) && i < params.count(); ++i) {
128
    if (params.at(i)->is_ret_param()) {
129
      // do nothing ...
130
    } else {
131
      OZ (init_default_expr(func, idx, *(params.at(i))));
132
      OX (idx++);
133
    }
134
  }
135
  return ret;
136
}
137

138
int ObPLResolver::init_default_exprs(
139
  ObPLFunctionAST &func, const ObIArray<ObPLRoutineParam *> &params)
140
{
141
  int ret = OB_SUCCESS;
142
  for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
143
    CK (OB_NOT_NULL(params.at(i)));
144
    OZ (init_default_expr(func, i, *(params.at(i))));
145
  }
146
  return ret;
147
}
148

149
int ObPLResolver::init_default_expr(
150
  ObPLFunctionAST &func_ast, int64_t idx, const share::schema::ObIRoutineParam &param)
151
{
152
  int ret = OB_SUCCESS;
153
  if (!param.get_default_value().empty()) {
154
    ObPLSymbolTable &symbol_table = func_ast.get_symbol_table();
155
    const ObPLVar *var = symbol_table.get_symbol(idx);
156
    CK (OB_NOT_NULL(var));
157
    OZ (init_default_expr(func_ast, param, var->get_type()));
158
    OX ((const_cast<ObPLVar *>(var))->set_default(func_ast.get_expr_count() - 1));
159
  }
160
  return ret;
161
}
162

163
int ObPLResolver::init_default_expr(ObPLFunctionAST &func_ast,
164
                                    const share::schema::ObIRoutineParam &param,
165
                                    const ObPLDataType &expected_type)
166
{
167
  int ret = OB_SUCCESS;
168
  if (!param.get_default_value().empty()) {
169
    const ParseNode *default_node = NULL;
170
    ObRawExpr *default_expr = NULL;
171
    ObString default_value = param.get_default_value();
172
    OZ (ObSQLUtils::convert_sql_text_from_schema_for_resolve(
173
          resolve_ctx_.allocator_, resolve_ctx_.session_info_.get_dtc_params(), default_value));
174
    OZ (ObRawExprUtils::parse_default_expr_from_str(
175
      default_value,
176
      resolve_ctx_.session_info_.get_charsets4parser(),
177
      resolve_ctx_.allocator_,
178
      default_node));
179
    CK (OB_NOT_NULL(default_node));
180
    OZ (resolve_expr(default_node, func_ast, default_expr,
181
         combine_line_and_col(default_node->stmt_loc_), true, &expected_type));
182
    CK (OB_NOT_NULL(default_expr));
183
  }
184
  return ret;
185
}
186

187
#define RESOLVE_CHILDREN(node, compile_unit) \
188
  do { \
189
    if (OB_NOT_NULL(node)) { \
190
      for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) { \
191
        if (NULL != node->children_[i]) { \
192
          OZ (SMART_CALL(resolve(node->children_[i], compile_unit))); \
193
        } \
194
      } \
195
    } \
196
  } while (0)
197

198
#define RESOLVE_STMT(stmt_type, resolve_func, stmt_def) \
199
  do { \
200
    ObPLStmtType type = stmt_type; \
201
    if (OB_FAIL(stmt_factory_.allocate(type, current_block_, stmt))) { \
202
      LOG_WARN("failed to alloc stmt", K(ret)); \
203
    } else if (OB_FAIL(resolve_func(parse_tree, static_cast<stmt_def*>(stmt), func))) { \
204
      LOG_WARN("failed to resolve pl stmt", K(parse_tree->type_), K(parse_tree), K(stmt), K(ret)); \
205
    } else if (type != PL_SQL) { \
206
      func.set_is_all_sql_stmt(false); \
207
    } \
208
  } while (0)
209

210
#define NO_EXCEPTION_STMT(type) ( PL_BLOCK == type \
211
    || PL_USER_TYPE == type \
212
    || PL_LEAVE == type \
213
    || PL_ITERATE == type \
214
    || PL_LOOP == type \
215
    || PL_COND == type \
216
    || PL_HANDLER == type \
217
    || PL_CURSOR == type \
218
    || PL_ROUTINE_DEF == type \
219
    || PL_ROUTINE_DECL == type \
220
  )
221

222
int ObPLResolver::resolve(const ObStmtNodeTree *parse_tree, ObPLFunctionAST &func)
223
{
224
  int ret = OB_SUCCESS;
225
  if (OB_ISNULL(parse_tree)) {
226
    ret = OB_INVALID_ARGUMENT;
227
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(ret));
228
  } else {
229
    ObPLStmt *stmt = NULL;
230
    ObString label;
231
    ObSEArray<ObString, 4> labels;
232
    ObString end_label;
233
    ObPLLabelTable *pl_label = NULL;
234
    int64_t label_idx = OB_INVALID_INDEX;
235
    if (T_SP_LABELED_BLOCK == parse_tree->type_ || T_SP_LABELED_CONTROL == parse_tree->type_) {
236
      // Oracle可以只有EndLabel,没有BeginLabel, 且EndLabel可以与BeginLabel不匹配
237
      // 如下用例在Oracle下是合法的
238
      // example 1: <<label>> BEGIN NULL; END label1;
239
      // example 2: BEGIN NULL; END label;
240
      ParseNode *labels_node = parse_tree->children_[0];
241
      if (OB_NOT_NULL(labels_node)) {
242
        if (T_LABEL_LIST == labels_node->type_) {
243
          for (int64_t i = 0; OB_SUCC(ret) && i < labels_node->num_child_; ++i) {
244
            label.reset();
245
            if (OB_FAIL(resolve_ident(labels_node->children_[i], label))) {
246
              LOG_WARN("failed to resolve ident", K(labels_node->children_[i]), K(ret));
247
            } else if (OB_FAIL(labels.push_back(label))) {
248
              LOG_WARN("failed to push labels", K(label), K(labels.count()), K(ret));
249
            } else {
250
              // do nothing
251
            }
252
          }
253
        } else if (OB_FAIL(resolve_ident(parse_tree->children_[0], label))) {
254
          LOG_WARN("failed to resolve ident",  K(parse_tree->children_[0]), K(ret));
255
        } else if (OB_FAIL(labels.push_back(label))) {
256
          LOG_WARN("failed to push labels", K(label), K(labels.count()), K(ret));
257
        }
258
      }
259
      if (OB_SUCC(ret) && NULL != parse_tree->children_[2]) {
260
        if (OB_FAIL(resolve_ident(parse_tree->children_[2], end_label))) {
261
          LOG_WARN("failed to resolve ident", K(parse_tree->children_[2]), K(ret));
262
        } else if (lib::is_mysql_mode()) {
263
          bool find_flag = false;
264
          for (int64_t i = 0; i < labels.count(); ++i) {
265
            if (0 == labels.at(i).case_compare(end_label)) {
266
              find_flag = true;
267
            }
268
          }
269
          if (!find_flag) {
270
            ret =  OB_ERR_SP_LILABEL_MISMATCH;
271
            LOG_WARN("begin label is not match with end label", K(label), K(end_label), K(ret));
272
          }
273
        } else { // Oracle的EndLabel行为, 仅对Procedure和Function结尾的EndLabel做匹配检查
274
          if (NULL != current_block_
275
              && NULL == current_block_->get_namespace().get_pre_ns()) {
276
            if (func.get_name().case_compare("__anonymous_block__") != 0
277
                && end_label.compare(func.get_name()) != 0) {
278
              ret =  OB_ERR_END_LABEL_NOT_MATCH;
279
              LOG_WARN("begin label is not match with end label", K(label), K(end_label), K(ret));
280
              LOG_USER_ERROR(OB_ERR_END_LABEL_NOT_MATCH,
281
                             end_label.length(), end_label.ptr(),
282
                             func.get_name().length(), func.get_name().ptr());
283
            }
284
          }
285
        }
286
      }
287
      if (OB_SUCC(ret)) {
288
        if (NULL != current_block_ && OB_NOT_NULL(parse_tree->children_[0])) {
289
          ObPLLabelTable::ObPLLabelType type =
290
            T_SP_LABELED_BLOCK == parse_tree->type_ ?
291
              ObPLLabelTable::ObPLLabelType::LABEL_BLOCK
292
            : ObPLLabelTable::ObPLLabelType::LABEL_CONTROL;
293
          for (int64_t i = 0; i < labels.count(); ++i) {
294
            OZ (current_block_->get_namespace().add_label(labels.at(i), type, NULL),
295
                                                                labels.at(i), type);
296
          }
297
          pl_label = current_block_->get_namespace().get_label_table();
298
          label_idx = pl_label->get_count() - 1;
299
        } else { /*do nothing*/ }
300
        parse_tree = parse_tree->children_[1];
301
      }
302
    }
303

304
    if (OB_SUCC(ret)) {
305
      switch (parse_tree->type_) {
306
      case T_SP_PROC_STMT_LIST:
307
      case T_SP_BLOCK_CONTENT: {
308
        ObPLStmtBlock *block = NULL;
309
        ++current_level_;
310
        if (OB_FAIL(resolve_stmt_list(parse_tree, block, func))) {
311
          LOG_WARN("failed to resolve stmt list", K(parse_tree->type_), K(ret));
312
        } else if (OB_FAIL(handler_analyzer_.reset_handlers(current_level_))) {
313
          LOG_WARN("failed to reset handlers", K(ret));
314
        } else {
315
          --current_level_;
316
          handler_analyzer_.reset_notfound_and_warning(current_level_);
317
          if (lib::is_oracle_mode() && current_level_ <= 1 && func.is_autonomous()) {
318
            block->set_is_autonomous();
319
          }
320
          stmt = block;
321
        }
322
      }
323
        break;
324
      case T_SP_DECL_LIST: {
325
        RESOLVE_CHILDREN(parse_tree, func);
326
      }
327
        break;
328
      case T_SP_DECL: {
329
        const ObStmtNodeTree *type_node = parse_tree->children_[1];
330
        ObPLDataType data_type;
331
        ObString ident_name;
332
        CK (OB_NOT_NULL(type_node));
333
        OZ (resolve_sp_data_type(type_node, ident_name, func, data_type));
334
        if (OB_SUCC(ret)) {
335
          if (!data_type.is_cursor_type() || data_type.is_rowtype_type()) {
336
            RESOLVE_STMT(PL_VAR, resolve_declare_var, ObPLDeclareVarStmt);
337
          } else {
338
#ifdef OB_BUILD_ORACLE_PL
339
            RESOLVE_STMT(PL_CURSOR, resolve_declare_ref_cursor, ObPLDeclareCursorStmt);
340
            func.set_modifies_sql_data();
341
#endif
342
          }
343
        }
344
      }
345
        break;
346
#ifdef OB_BUILD_ORACLE_PL
347
      case T_SP_DECL_USER_TYPE: {
348
        RESOLVE_STMT(PL_USER_TYPE, resolve_declare_user_type, ObPLDeclareUserTypeStmt);
349
      }
350
        break;
351
      case T_SP_DECL_USER_SUBTYPE: {
352
        RESOLVE_STMT(PL_USER_SUBTYPE, resolve_declare_user_subtype, ObPLDeclareUserTypeStmt);
353
      }
354
#endif
355
        break;
356
      case T_VARIABLE_SET: {
357
        RESOLVE_STMT(PL_ASSIGN, resolve_assign, ObPLAssignStmt);
358
        OZ (try_transform_assign_to_dynamic_SQL(stmt, func));
359
      }
360
        break;
361
      case T_SP_IF: {
362
        RESOLVE_STMT(PL_IF, resolve_if, ObPLIfStmt);
363
      }
364
        break;
365
      case T_SP_CASE: {
366
        RESOLVE_STMT(PL_CASE, resolve_case, ObPLCaseStmt);
367
      }
368
        break;
369
      case T_SP_ITERATE: {
370
        RESOLVE_STMT(PL_ITERATE, resolve_iterate, ObPLIterateStmt);
371
      }
372
        break;
373
      case T_SP_LEAVE: {
374
        RESOLVE_STMT(PL_LEAVE, resolve_leave, ObPLLeaveStmt);
375
      }
376
        break;
377
      case T_SP_WHILE: {
378
        RESOLVE_STMT(PL_WHILE, resolve_while, ObPLWhileStmt);
379
      }
380
        break;
381
      case T_SP_FOR_LOOP: {
382
        RESOLVE_STMT(PL_FOR_LOOP, resolve_for_loop, ObPLForLoopStmt);
383
      }
384
        break;
385
      case T_SP_CURSOR_FOR_LOOP: {
386
        RESOLVE_STMT(PL_CURSOR_FOR_LOOP, resolve_cursor_for_loop, ObPLCursorForLoopStmt);
387
        if (!func.is_modifies_sql_data()) {
388
          func.set_reads_sql_data();
389
        }
390
      }
391
        break;
392
      case T_SP_FORALL: {
393
        RESOLVE_STMT(PL_FORALL, resolve_forall, ObPLForAllStmt);
394
        func.set_modifies_sql_data();
395
      }
396
        break;
397
      case T_SP_REPEAT: {
398
        RESOLVE_STMT(PL_REPEAT, resolve_repeat, ObPLRepeatStmt);
399
      }
400
        break;
401
      case T_SP_LOOP: {
402
        RESOLVE_STMT(PL_LOOP, resolve_loop, ObPLLoopStmt);
403
      }
404
        break;
405
      case T_SP_RETURN: {
406
        RESOLVE_STMT(PL_RETURN, resolve_return, ObPLReturnStmt);
407
        // OB_ERR_FUNCTION_UNKNOWN need set too.
408
        // case: CREATE FUNCTION f1() RETURNS INT RETURN f1()
409
        if (lib::is_mysql_mode()
410
            && (OB_SUCCESS == ret
411
                || OB_ERR_FUNCTION_UNKNOWN == ret
412
                || OB_ERR_SP_DOES_NOT_EXIST == ret)) {
413
          func.set_return();
414
        }
415
      }
416
        break;
417
      case T_TRANSACTION:
418
      case T_SQL_STMT: {
419
        RESOLVE_STMT(PL_SQL, resolve_sql, ObPLSqlStmt);
420
      }
421
        break;
422
      case T_SP_EXECUTE_IMMEDIATE: {
423
        RESOLVE_STMT(PL_EXECUTE, resolve_execute_immediate, ObPLExecuteStmt);
424
        func.set_modifies_sql_data();
425
      }
426
        break;
427
      case T_SP_DO: {
428
        RESOLVE_STMT(PL_DO, resolve_do, ObPLDoStmt);
429
        if (lib::is_mysql_mode()) {
430
          if (!func.is_reads_sql_data() && !func.is_modifies_sql_data()) {
431
            func.set_contains_sql();
432
          }
433
        }
434
      }
435
        break;
436
      case T_SP_EXTEND: {
437
        RESOLVE_STMT(PL_EXTEND, resolve_extend, ObPLExtendStmt);
438
      }
439
        break;
440
      case T_SP_INIT_PRAGMA:
441
      case T_SP_DECL_COND: {
442
        RESOLVE_STMT(PL_COND, resolve_declare_cond, ObPLDeclareCondStmt);
443
      }
444
        break;
445
      case T_SP_DECL_HANDLER: {
446
        if (OB_ISNULL(current_block_)) {
447
          ret = OB_ERR_UNEXPECTED;
448
          LOG_WARN("current block is NULL", K(current_block_), K(ret));
449
        } else {
450
          if (current_block_->has_eh()) {
451
            stmt = NULL;
452
          } else if (OB_FAIL(stmt_factory_.allocate(PL_HANDLER, current_block_, stmt))) {
453
            LOG_WARN("failed to alloc stmt", K(ret));
454
          }
455
        }
456
        if (OB_SUCC(ret)) {
457
          if (OB_FAIL(check_declare_order(PL_HANDLER))) {
458
            LOG_WARN("fail to check decalre order", K(ret));
459
          } else if (OB_FAIL(resolve_declare_handler(parse_tree, static_cast<ObPLDeclareHandlerStmt*>(NULL == stmt ? current_block_->get_eh() : stmt), func))) {
460
            LOG_WARN("failed to resolve declare handler stmt", K(parse_tree), K(stmt), K(ret));
461
          } else if (stmt != NULL && static_cast<ObPLDeclareHandlerStmt*>(stmt)->get_handlers().count() <= 0) {
462
            // continue handler will record into handler_analyzer_,
463
            // so here handlers may null, do not add null handler to current block.
464
            stmt = NULL;
465
          }
466
          if (OB_SUCC(ret)) {
467
            func.set_is_all_sql_stmt(false);
468
          }
469
        }
470
      }
471
        break;
472
      case T_SP_RESIGNAL: {
473
        RESOLVE_STMT(PL_SIGNAL, resolve_resignal, ObPLSignalStmt);
474
        if (lib::is_mysql_mode() && !func.is_reads_sql_data() && !func.is_modifies_sql_data()) {
475
          func.set_contains_sql();
476
        }
477
      }
478
        break;
479
      case T_SP_SIGNAL: {
480
        RESOLVE_STMT(PL_SIGNAL, resolve_signal, ObPLSignalStmt);
481
        if (lib::is_mysql_mode() && !func.is_reads_sql_data() && !func.is_modifies_sql_data()) {
482
          func.set_contains_sql();
483
        }
484
      }
485
        break;
486
      case T_SP_CALL_STMT: {
487
        RESOLVE_STMT(PL_CALL, resolve_call, ObPLCallStmt);
488
        func.set_external_state();
489
      }
490
        break;
491
      case T_SP_INNER_CALL_STMT: {
492
        if (OB_FAIL(resolve_inner_call(parse_tree, stmt, func))) {
493
          LOG_WARN("failed to resolve inner call", K(parse_tree), K(ret));
494
        } else {
495
          func.set_is_all_sql_stmt(false);
496
        }
497
      }
498
        break;
499
      case T_SP_DECL_CURSOR: {
500
        if (OB_FAIL(check_declare_order(PL_CURSOR))) {
501
          LOG_WARN("fail to check decalre order", K(ret));
502
        } else {
503
          RESOLVE_STMT(PL_CURSOR, resolve_declare_cursor, ObPLDeclareCursorStmt);
504
          if (!func.is_modifies_sql_data()) {
505
            func.set_reads_sql_data();
506
          }
507
        }
508
      }
509
        break;
510
      case T_SP_PROC_OPEN: {
511
        if (NULL == parse_tree->children_[2]) {
512
          RESOLVE_STMT(PL_OPEN, resolve_open, ObPLOpenStmt);
513
        } else {
514
          RESOLVE_STMT(PL_OPEN_FOR, resolve_open_for, ObPLOpenForStmt);
515
        }
516
      }
517
        break;
518
      case T_SP_PROC_FETCH: {
519
        RESOLVE_STMT(PL_FETCH, resolve_fetch, ObPLFetchStmt);
520
      }
521
        break;
522
      case T_SP_PROC_CLOSE: {
523
        RESOLVE_STMT(PL_CLOSE, resolve_close, ObPLCloseStmt);
524
      }
525
        break;
526
      case T_SP_NULL: {
527
        RESOLVE_STMT(PL_NULL, resolve_null, ObPLNullStmt);
528
      }
529
        break;
530
      case T_SP_PIPE_ROW: {
531
        RESOLVE_STMT(PL_PIPE_ROW, resolve_pipe_row, ObPLPipeRowStmt);
532
      }
533
        break;
534
      case T_STMT_LIST: //TODO: delete me ..@rudian
535
      case T_PACKAGE_BODY_STMTS: {
536
        RESOLVE_CHILDREN(parse_tree, func);
537
      }
538
        break;
539
      case T_SP_SOURCE: {
540
        if (OB_FAIL(resolve_root(parse_tree->children_[3], func))) {
541
          LOG_WARN("failed to resolve sp source", K(current_block_), K(ret));
542
        }
543
      }
544
        break;
545
      case T_SF_AGGREGATE_SOURCE:
546
      case T_SF_SOURCE: {
547
          if (OB_NOT_NULL(parse_tree) && OB_NOT_NULL(parse_tree->children_[4])) {
548
            OZ (SMART_CALL(resolve(parse_tree->children_[4], func)));
549
          }
550
          OZ (SMART_CALL(resolve_root(parse_tree->children_[5], func)));
551
        }
552
          break;
553
      case T_SP_CREATE:
554
      case T_SF_CREATE: {
555
        ret = OB_ER_SP_NO_RECURSIVE_CREATE;
556
        LOG_WARN("Can't create a routine from within another routine", K(ret));
557
        LOG_USER_ERROR(OB_ER_SP_NO_RECURSIVE_CREATE);
558
      }
559
        break;
560
      case T_SUB_FUNC_DECL: //fall through
561
      case T_SUB_PROC_DECL: {
562
        ObPLRoutineInfo *routine_info = NULL;
563
        if (OB_FAIL(resolve_routine_decl(parse_tree, func, routine_info, false))) {
564
          LOG_WARN("resolve routine declaration failed", K(parse_tree), K(ret));
565
        }
566
      }
567
        break;
568
      case T_SUB_FUNC_DEF: //fall through
569
      case T_SUB_PROC_DEF: {
570
        // must be nested routine, because udt member is process in package ast resolve
571
        if (OB_FAIL(resolve_routine_def(parse_tree, func, false))) {
572
          LOG_WARN("resolve procedure definition failed", K(parse_tree), K(ret));
573
        }
574
      }
575
        break;
576
      case T_SP_PRAGMA_INLINE: {
577
        // do nothing ...
578
      }
579
        break;
580
      case T_SP_PRAGMA_UDF: {
581
        if (OB_FAIL(resolve_udf_pragma(parse_tree, func))) {
582
          LOG_WARN("resolve udf pragma failed", K(ret), K(parse_tree), K(func));
583
        }
584
      }
585
        break;
586
      case T_SP_PRAGMA_INTERFACE: {
587
        RESOLVE_STMT(PL_INTERFACE, resolve_interface, ObPLInterfaceStmt);
588
      }
589
        break;
590
      case T_SP_PRAGMA_RESTRICT_REFERENCE:
591
      case T_SP_PRAGMA_SERIALLY_REUSABLE: {
592
        ret = OB_ERR_PARAM_IN_PACKAGE_SPEC;
593
        LOG_WARN("PLS-00708: Pragma string must be declared in a package specification", K(ret));
594
      }
595
        break;
596
      case T_SP_PRAGMA_AUTONOMOUS_TRANSACTION: {
597
        if (current_level_ > 1) {
598
          //oracle兼容：只能在第一个block中申明自治事务
599
          ret = OB_ERR_PRAGMA_ILLEGAL;
600
          LOG_USER_ERROR(OB_ERR_PRAGMA_ILLEGAL, "AUTONOMOUS_TRANSACTION");
601
        } else if (func.is_autonomous()) {
602
          ret = OB_ERR_PRAGMA_DECL_TWICE;
603
          LOG_USER_ERROR(OB_ERR_PRAGMA_DECL_TWICE,
604
                         ObString("AUTONOMOUS_TRANSACTION").length(),
605
                         ObString("AUTONOMOUS_TRANSACTION").ptr());
606
        } else {
607
          func.set_autonomous();
608
        }
609
      }
610
        break;
611
      case T_SP_GOTO: {
612
        RESOLVE_STMT(PL_GOTO, resolve_goto, ObPLGotoStmt);
613
      }
614
        break;
615
      case T_SP_PRE_STMTS: {
616
        const ParseNode *new_node = NULL;
617
        OZ (ObPLResolver::resolve_condition_compile(
618
          resolve_ctx_.allocator_,
619
          &(resolve_ctx_.session_info_),
620
          &(resolve_ctx_.schema_guard_),
621
          &(resolve_ctx_.package_guard_),
622
          &(resolve_ctx_.sql_proxy_),
623
          NULL,
624
          parse_tree,
625
          new_node,
626
          false,
627
          false,
628
          false,
629
          NULL,
630
          &(func.get_dependency_table())));
631
        CK (OB_NOT_NULL(new_node));
632
        OZ (SMART_CALL(resolve(new_node, func)));
633
      }
634
        break;
635
#define NOT_SUPPORT_IN_ROUTINE \
636
  ret = OB_NOT_SUPPORTED;       \
637
  LOG_WARN("Not support parser node", K(get_type_name(parse_tree->type_)), K(ret));
638
  LOG_USER_ERROR(OB_NOT_SUPPORTED, "parser node");
639
  LOG_USER_ERROR(OB_NOT_SUPPORTED, get_type_name(parse_tree->type_));
640

641
      case T_SF_ALTER:
642
      case T_SF_DROP: {
643
        ret = OB_ERR_SP_NO_DROP_SP;
644
        LOG_WARN("DDL SQL is not allowed in stored function", K(ret));
645
        LOG_USER_ERROR(OB_ERR_SP_NO_DROP_SP, "FUNCTION");
646
      }
647
        break;
648
      case T_SP_ALTER:
649
      case T_SP_DROP: {
650
        ret = OB_ERR_SP_NO_DROP_SP;
651
        LOG_WARN("DDL SQL is not allowed in stored function", K(ret));
652
        LOG_USER_ERROR(OB_ERR_SP_NO_DROP_SP, "PROCEDURE");
653
      }
654
        break;
655
      case T_TG_ALTER:
656
      case T_TG_DROP:
657
      case T_TG_CREATE: {
658
        if ((resolve_ctx_.session_info_.is_for_trigger_package() || func.is_function())) {
659
         ret = OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG;
660
         LOG_WARN("DDL SQL is not allowed in stored function", K(ret));
661
        } else {
662
          NOT_SUPPORT_IN_ROUTINE
663
        }
664
      }
665
        break;
666
      default:
667
        NOT_SUPPORT_IN_ROUTINE
668
        break;
669
      }
670
#undef NOT_SUPPORT_IN_ROUTINE
671

672
      // MySQL兼容: 对于对象不存在的错误，resolve阶段不报错,这里替换为一个single语句，在执行阶段报错
673
      // 由于对象的创建可能在sp的创建之后，因此这里不将加了single语句的function放入cache
674
      if ((OB_ERR_FUNCTION_UNKNOWN == ret
675
           || OB_ERR_SP_WRONG_ARG_NUM == ret
676
           || OB_ERR_SP_DOES_NOT_EXIST == ret
677
           || OB_ERR_GET_STACKED_DIAGNOSTICS == ret
678
           || OB_ERR_RESIGNAL_WITHOUT_ACTIVE_HANDLER == ret)
679
          && lib::is_mysql_mode()) {
680
        ObPLSignalStmt *signal_stmt = NULL;
681
        int save_ret = ret;
682
        if (OB_FAIL(stmt_factory_.allocate(PL_SIGNAL, current_block_, stmt))) {
683
          LOG_WARN("failed to alloc stmt", K(ret));
684
        } else if (OB_ISNULL(signal_stmt = static_cast<ObPLSignalStmt*>(stmt))) {
685
          ret = OB_ERR_UNEXPECTED;
686
          LOG_WARN("static cast failed", K(ret));
687
        } else {
688
          if (-1 == ob_mysql_errno(save_ret)) {
689
            signal_stmt->set_cond_type(SQL_STATE);
690
          } else {
691
            signal_stmt->set_cond_type(ERROR_CODE);
692
          }
693
          signal_stmt->set_error_code(ob_errpkt_errno(save_ret, lib::is_oracle_mode()));
694
          signal_stmt->set_ob_error_code(save_ret);
695
          signal_stmt->set_sql_state(ob_sqlstate(save_ret));
696
          signal_stmt->set_str_len(STRLEN(ob_sqlstate(save_ret)));
697
          func.set_can_cached(false);
698
          func.set_is_all_sql_stmt(false);
699
          if (lib::is_mysql_mode() && !func.is_reads_sql_data() && !func.is_modifies_sql_data()) {
700
            func.set_contains_sql();
701
          }
702
        }
703
      }
704

705
      if (OB_SUCC(ret) && handler_analyzer_.in_continue()  && NULL != stmt && !NO_EXCEPTION_STMT(stmt->get_type())) {
706
        // for continue handler, should add handler to every stmt, here, make a new block, consturct new block with handler and stmt.
707
        ObPLStmtBlock *block = NULL;
708
        if (OB_FAIL(make_block(func, current_block_, block))) {
709
          LOG_WARN("failed to make block", K(current_block_), K(ret));
710
        } else {
711
          ObPLStmt *stmt = NULL;
712
          ObPLDeclareHandlerStmt *declare_handler_stmt = NULL;
713
          if (OB_FAIL(stmt_factory_.allocate(PL_HANDLER, block, stmt))) {
714
            LOG_WARN("failed to alloc stmt", K(ret));
715
          } else if (OB_ISNULL(declare_handler_stmt = static_cast<ObPLDeclareHandlerStmt*>(stmt))) {
716
            ret = OB_ERR_UNEXPECTED;
717
            LOG_WARN("failed to allocate stmt", K(current_block_), K(ret));
718
          } else if (OB_FAIL(block->add_stmt(declare_handler_stmt))) {
719
            LOG_WARN("failed to add stmt", K(declare_handler_stmt), K(ret));
720
          } else {
721
            block->set_eh(declare_handler_stmt);
722
            ObPLDeclareHandlerStmt::DeclareHandler handler_info;
723
            for (int64_t i = handler_analyzer_.get_continue(); OB_SUCC(ret) && i < handler_analyzer_.get_stack_depth(); ++i) {
724
              if (OB_FAIL(handler_analyzer_.get_handler(i, handler_info))) {
725
                LOG_WARN("failed to get handler", K(i), K(ret));
726
              } else if (OB_FAIL(declare_handler_stmt->add_handler(handler_info))) {
727
                LOG_WARN("failed to add handler", K(handler_info), K(ret));
728
              } else { /*do nothing*/ }
729
            }
730
          }
731
        }
732
        if (OB_SUCC(ret)) {
733
          if (OB_FAIL(block->add_stmt(stmt))) {
734
            LOG_WARN("failed to add stmt", K(stmt), K(ret));
735
          } else {
736
            stmt->set_block(block);
737
            stmt = block;
738
          }
739
        }
740
      }
741

742
      if (OB_SUCC(ret) && NULL != stmt) {
743
        ObPLStmtBlock *pl_stmt_block = static_cast<ObPLStmtBlock *>(stmt);
744
        if (PL_BLOCK == stmt->get_type() && pl_stmt_block != NULL && pl_stmt_block->get_is_autonomous()) {
745
          for (int64_t i = 0; OB_SUCC(ret) && i < pl_stmt_block->get_stmts().count(); ++i) {
746
            ObPLStmt *sub_stmt = pl_stmt_block->get_stmts().at(i);
747
            if (PL_BLOCK == sub_stmt->get_type()) {
748
              static_cast<ObPLStmtBlock *>(sub_stmt)->clear_aotonomous();
749
            }
750
          }
751
        }
752
        stmt->set_level(current_level_);
753
        stmt->set_location(parse_tree->stmt_loc_.first_line_, parse_tree->stmt_loc_.first_column_);
754
        int64_t lbls_cnt = labels.count();
755
        // 这儿只能用label idx，而不是label_table的count(), 是因为这个函数resolve过程中会递归
756
        // 所以可能子过程里面会push很多labels进去，递归退出到这儿的时候，label_idx和count()就对不上了。
757
        if (OB_NOT_NULL(pl_label) && OB_INVALID_INDEX != label_idx) {
758
          for (int64_t i = 0; OB_SUCC(ret) && i < lbls_cnt; ++i) {
759
            CK (0 <= (label_idx - i));
760
            OX (stmt->set_label_idx(label_idx - i));
761
            OX (pl_label->set_end_flag(label_idx - i, true));
762
          }
763
        }
764
      }
765
      if (OB_FAIL(ret)) {
766
        if (NULL != stmt) {
767
          stmt->~ObPLStmt();
768
        }
769
      } else if (NULL != current_block_ && NULL != stmt) {
770
        if (OB_FAIL(current_block_->add_stmt(stmt))) {
771
          LOG_WARN("failed to add stmt", K(stmt), K(ret));
772
          if (NULL != stmt) {
773
            stmt->~ObPLStmt();
774
          }
775
        }
776
      }
777
    }
778
    if (OB_FAIL(ret)) {
779
      record_error_line(parse_tree, resolve_ctx_.session_info_);
780
    }
781
  }
782
  return ret;
783
}
784

785
int ObPLResolver::resolve_root(const ObStmtNodeTree *parse_tree, ObPLFunctionAST &func)
786
{
787
  int ret = OB_SUCCESS;
788
  if (OB_FAIL(resolve(parse_tree, func))) {
789
    LOG_WARN("failed to resolve pl.", K(ret));
790
  } else if (OB_FAIL(resolve_goto_stmts(func))) {
791
    LOG_WARN("failed to resolve goto stmts", K(ret));
792
  } else if (OB_FAIL(check_subprogram(func))) {
793
    LOG_WARN("faield to check subprogram", K(ret));
794
  }
795
  return ret;
796
}
797

798
int ObPLResolver::check_subprogram(ObPLFunctionAST &func)
799
{
800
  int ret = OB_SUCCESS;
801
  ObPLRoutineTable &routine_table = func.get_routine_table();
802
  common::ObIArray<ObPLRoutineInfo *> &routine_infos = routine_table.get_routine_infos();
803
  for (int64_t i = 0; OB_SUCC(ret) && i < routine_infos.count(); ++i) {
804
    ObPLFunctionAST *routine_ast = NULL;
805
    CK (OB_NOT_NULL(routine_infos.at(i)));
806
    OZ (routine_table.get_routine_ast(i, routine_ast));
807
    if (OB_SUCC(ret) && OB_ISNULL(routine_ast)) {
808
      ret = OB_ERR_ROUTINE_NOT_DEFINE;
809
      LOG_USER_ERROR(OB_ERR_ROUTINE_NOT_DEFINE,
810
                     routine_infos.at(i)->get_name().length(),
811
                     routine_infos.at(i)->get_name().ptr());
812
      LOG_WARN("A subprogram body must be defined for the forward declaration of string.",
813
               K(ret), K(i));
814
    }
815
  }
816
  return ret;
817
}
818

819
int ObPLResolver::resolve_goto_stmts(ObPLFunctionAST &func_ast)
820
{
821
  UNUSED(func_ast);
822
  int ret = OB_SUCCESS;
823
  int64_t cnt = get_goto_stmts().count();
824
  ObPLStmt *goto_stmt = NULL;
825
    for (int64_t i = 0; OB_SUCC(ret) && i < cnt; ++i) {
826
      goto_stmt = get_goto_stmts().at(i);
827
      if (OB_ISNULL(goto_stmt)) {
828
        ret = OB_ERR_UNEXPECTED;
829
        LOG_WARN("goto stmt is null", K(ret));
830
      } else {
831
        switch (goto_stmt->get_type()) {
832
          case PL_GOTO: {
833
            if (OB_FAIL(check_goto(static_cast<ObPLGotoStmt *>(goto_stmt)))) {
834
              LOG_WARN("failed to resolve goto stmt", K(ret));
835
            }
836
          }
837
          break;
838
          default: {
839
            ret = OB_ERR_UNEXPECTED;
840
            LOG_WARN("cann't resolve other stmt again expect goto stmt", K(goto_stmt->get_type()));
841
          }
842
          break;
843
        }
844
      }
845
    }
846
    while (OB_SUCC(ret) && 0 < get_goto_stmts().count()) {
847
      OX (pop_goto_stmts());
848
    }
849
  return ret;
850
}
851

852
int ObPLResolver::init(ObPLPackageAST &package_ast)
853
{
854
  int ret = OB_SUCCESS;
855
  if (OB_FAIL(make_block(package_ast, current_block_))) {
856
    LOG_WARN("failed to make block", K(current_block_), K(ret));
857
  } else {
858
    current_level_ = 0;
859
    package_ast.set_body(current_block_);
860
    external_ns_.set_dependency_table(&package_ast.get_dependency_table());
861
    current_block_->get_namespace().set_explicit_block();
862

863
    /*
864
     * NOTE: only set label for package spec.
865
     *   for self pacakge label variable(such as pkg.var), alreays search start at package spec.
866
     *   public and private variables are all different with names.
867
     */
868
    if (ObPLBlockNS::BLOCK_PACKAGE_SPEC == current_block_->get_namespace().get_block_type()
869
        && !ObTriggerInfo::is_trigger_package_id(package_ast.get_id())) {
870
      OZ (current_block_->get_namespace().add_label(
871
        package_ast.get_name(), ObPLLabelTable::ObPLLabelType::LABEL_BLOCK, NULL));
872
    }
873
    if (!resolve_ctx_.package_guard_.is_inited()) {
874
      OZ (resolve_ctx_.package_guard_.init());
875
    }
876
  }
877
  return ret;
878
}
879

880
#define RESOLVE_PACKAGE_STMT(node, compile_unit) \
881
  do { \
882
    if (OB_NOT_NULL(node)) { \
883
      int save_ret = OB_SUCCESS; \
884
      for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) { \
885
        if (NULL != node->children_[i]) { \
886
          if (OB_FAIL(SMART_CALL(resolve(node->children_[i], compile_unit)))) { \
887
            save_ret = ret; \
888
            ret = is_object_not_exist_error(ret) ? OB_SUCCESS : ret; \
889
            LOG_WARN("failed to resolve package stmts", K(ret), K(i)); \
890
          } \
891
        } \
892
      } \
893
      ret = OB_SUCCESS == ret ? save_ret : ret; \
894
    } \
895
  } while (0)
896

897

898
int ObPLResolver::resolve(const ObStmtNodeTree *parse_tree, ObPLPackageAST &package_ast)
899
{
900
  int ret = OB_SUCCESS;
901
  if (OB_ISNULL(parse_tree)) {
902
    ret = OB_INVALID_ARGUMENT;
903
    LOG_WARN("parse_tree is NULL or invalid", K(parse_tree), K(ret));
904
  } else {
905
    switch (parse_tree->type_) {
906
    case T_PACKAGE_BLOCK: {
907
      if (PACKAGE_BLOCK_NUM_CHILD != parse_tree->num_child_) {
908
        ret = OB_INVALID_ARGUMENT;
909
        LOG_WARN("package block parse tree invalid", K(ret));
910
      } else if (OB_NOT_NULL(parse_tree->children_[2])) {
911
        OZ (SMART_CALL(resolve(parse_tree->children_[2], package_ast)));
912
      }
913
    }
914
      break;
915
    case T_PACKAGE_STMTS: {
916
      RESOLVE_PACKAGE_STMT(parse_tree, package_ast);
917
    }
918
      break;
919
    case T_PACKAGE_BODY_BLOCK: {
920
      if (PACKAGE_BODY_BLOCK_NUM_CHILD != parse_tree->num_child_) {
921
        ret = OB_INVALID_ARGUMENT;
922
        LOG_WARN("package body block parse_tree invalid", K(ret));
923
      } else {
924
        if (OB_NOT_NULL(parse_tree->children_[1])) {
925
          OZ (SMART_CALL(resolve(parse_tree->children_[1], package_ast)));
926
        }
927
        if (OB_SUCC(ret) && OB_NOT_NULL(parse_tree->children_[2])) {
928
          OZ (SMART_CALL(resolve(parse_tree->children_[2], package_ast)));
929
        }
930
      }
931
    }
932
      break;
933
    case T_SP_CREATE_TYPE_BODY_SRC: {
934
      if (2 != parse_tree->num_child_) {
935
        ret = OB_INVALID_ARGUMENT;
936
        LOG_WARN("type body block invalid", K(ret));
937
      } else {
938
        if (OB_NOT_NULL(parse_tree->children_[1])) {
939
          OZ (SMART_CALL(resolve(parse_tree->children_[1], package_ast)));
940
        }
941
      }
942
    }
943
      break;
944
    case T_SP_OBJECT_BODY_DEF: {
945
      for (int64_t i = 0; OB_SUCC(ret) && i < parse_tree->num_child_; ++i) {
946
        OZ (SMART_CALL(resolve(parse_tree->children_[i], package_ast)));
947
      }
948
    }
949
      break;
950
    case T_PACKAGE_BODY_STMTS: {
951
      RESOLVE_CHILDREN(parse_tree, package_ast);
952
    }
953
      break;
954
    case T_SP_DECL: {
955
      OZ (resolve_declare_var(parse_tree, package_ast));
956
      break;
957
    }
958
#ifdef OB_BUILD_ORACLE_PL
959
    case T_SP_DECL_USER_TYPE: {
960
      OZ (resolve_declare_user_type(parse_tree, package_ast));
961
      break;
962
    }
963
    case T_SP_DECL_USER_SUBTYPE: {
964
      OZ (resolve_declare_user_subtype(parse_tree, NULL, package_ast));
965
      break;
966
    }
967
#endif
968
    case T_SP_INIT_PRAGMA:
969
    case T_SP_DECL_COND: {
970
      OZ (resolve_declare_cond(parse_tree, package_ast));
971
      break;
972
    }
973
    case T_SUB_FUNC_DECL: //fall through
974
    case T_SUB_PROC_DECL: {
975
      ObPLRoutineInfo *routine_info = NULL;
976
      if (OB_FAIL(resolve_routine_decl(parse_tree, package_ast, routine_info))) {
977
        LOG_WARN("resolve routine declaration failed", K(parse_tree), K(ret));
978
      }
979
    }
980
      break;
981
    case T_SUB_FUNC_DEF: //fall through
982
    case T_SUB_PROC_DEF: {
983
      bool is_udt_routine = (ObPackageType::PL_UDT_OBJECT_SPEC == package_ast.get_package_type()
984
                         || ObPackageType::PL_UDT_OBJECT_BODY == package_ast.get_package_type()) ?
985
                         true : false;
986
      if (OB_FAIL(resolve_routine_def(parse_tree, package_ast, is_udt_routine))) {
987
        LOG_WARN("resolve procedure definition failed", K(parse_tree), K(ret));
988
      }
989
    }
990
      break;
991
    case T_STMT_LIST: {
992
      RESOLVE_CHILDREN(parse_tree, package_ast);
993
    }
994
      break;
995
    case T_SP_PROC_STMT_LIST: {
996
      if (OB_FAIL(resolve_init_routine(parse_tree, package_ast))) {
997
        LOG_WARN("resolve init routine failed", K(parse_tree), K(ret));
998
      }
999
    }
1000
      break;
1001
    case T_SP_PRAGMA_INLINE: {
1002
      // do nothing ...
1003
    }
1004
      break;
1005
    case T_SP_PRAGMA_SERIALLY_REUSABLE: {
1006
      if (OB_FAIL(resolve_serially_reusable_pragma(parse_tree, package_ast))) {
1007
        LOG_WARN("resolve serially pragma failed", K(ret), K(parse_tree), K(package_ast));
1008
      }
1009
    }
1010
      break;
1011
    case T_SP_PRAGMA_RESTRICT_REFERENCE: {
1012
      if (OB_FAIL(resolve_restrict_references_pragma(parse_tree, package_ast))) {
1013
        LOG_WARN("resolve restrict references failed", K(ret), K(parse_tree), K(package_ast));
1014
      }
1015
    }
1016
      break;
1017
    case T_SP_PRAGMA_INTERFACE: {
1018
      if (OB_FAIL(resolve_interface_pragma(parse_tree, package_ast))) {
1019
        LOG_WARN("resolve restrict references failed", K(ret), K(parse_tree), K(package_ast));
1020
      }
1021
    }
1022
      break;
1023
    case T_SP_PRAGMA_UDF: {
1024
      ret = OB_ERR_PRAGMA_ILLEGAL;
1025
      LOG_USER_ERROR(OB_ERR_PRAGMA_ILLEGAL, "UDF");
1026
    }
1027
      break;
1028
    case T_SP_DECL_CURSOR: {
1029
      if (OB_FAIL(resolve_declare_cursor(parse_tree, package_ast))) {
1030
        LOG_WARN("resovle package cursor declare failed", K(ret), K(parse_tree), K(package_ast));
1031
      } else {
1032
        if (!package_ast.is_modifies_sql_data()) {
1033
          package_ast.set_reads_sql_data();
1034
        }
1035
      }
1036
    }
1037
      break;
1038
#ifdef OB_BUILD_ORACLE_PL
1039
    case T_SP_OBJ_ELEMENT_SPEC_LIST: {
1040
      OZ (resolve_object_elem_spec_list(parse_tree, package_ast));
1041
    }
1042
      break;
1043
    case T_SP_OBJ_ELEMENT_SPEC:
1044
    case T_SP_OBJ_ELEM_CONSTRUCTOR : {
1045
      OZ (resolve_object_elem_spec_def(parse_tree, package_ast));
1046
    }
1047
      break;
1048
    case T_SP_CREATE_TYPE_SRC : {
1049
      OZ (resolve_object_def(parse_tree, package_ast));
1050
    }
1051
      break;
1052
#endif
1053
    case T_SP_OBJ_CONSTR_IMPL : {
1054
      CK (OB_NOT_NULL(parse_tree));
1055
      OX (const_cast<ParseNode *>(parse_tree)->type_ = T_SUB_FUNC_DEF);
1056
      CK (OB_NOT_NULL(parse_tree->children_[0]));
1057
      OX (parse_tree->children_[0]->type_ = T_SUB_FUNC_DECL);
1058
      OZ (resolve_routine_def(parse_tree, package_ast, true));
1059
    }
1060
      break;
1061
    case T_SP_CONTRUCTOR_DEF_IN_TYPE : {
1062
      CK (OB_NOT_NULL(parse_tree));
1063
      CK (2 == parse_tree->num_child_);
1064
      OZ (SMART_CALL(resolve(parse_tree->children_[1], package_ast)));
1065
    }
1066
      break;
1067
    case T_SP_OBJ_MAP_ORDER: {
1068
      CK (OB_NOT_NULL(parse_tree));
1069
      CK (1 == parse_tree->num_child_);
1070
      CK (2 == parse_tree->int16_values_[0]); // map define, not decl
1071
      CK (OB_NOT_NULL(parse_tree->children_[0]));
1072
      OZ (resolve_routine_def(parse_tree->children_[0], package_ast, true));
1073
    }
1074
      break;
1075
#ifdef OB_BUILD_ORACLE_PL
1076
    case T_SP_PRE_STMTS: {
1077
      const ParseNode *new_node = NULL;
1078
      OZ (ObPLResolver::resolve_condition_compile(
1079
          resolve_ctx_.allocator_,
1080
          &(resolve_ctx_.session_info_),
1081
          &(resolve_ctx_.schema_guard_),
1082
          &(resolve_ctx_.package_guard_),
1083
          &(resolve_ctx_.sql_proxy_),
1084
          NULL,
1085
          parse_tree,
1086
          new_node,
1087
          false,
1088
          false,
1089
          false,
1090
          NULL,
1091
          &(package_ast.get_dependency_table())));
1092
      CK (OB_NOT_NULL(new_node));
1093
      OZ (ObPLUDTObjectManager::make_self_node(
1094
        resolve_ctx_.allocator_, const_cast<ParseNode *>(new_node), package_ast.get_name()));
1095
      OZ (SMART_CALL(resolve(new_node, package_ast)));
1096
    }
1097
      break;
1098
#endif
1099
    default: {
1100
      ret = OB_NOT_SUPPORTED;
1101
      LOG_WARN("Not support parser node", K(get_type_name(parse_tree->type_)), K(ret));
1102
      LOG_USER_ERROR(OB_NOT_SUPPORTED, get_type_name(parse_tree->type_));
1103
      break;
1104
    }
1105
    }
1106
    if (OB_FAIL(ret)) {
1107
      record_error_line(parse_tree, resolve_ctx_.session_info_);
1108
    }
1109
  }
1110
  return ret;
1111
}
1112

1113
#ifdef OB_BUILD_ORACLE_PL
1114
int ObPLResolver::resolve_object_def(const ParseNode *parse_tree, ObPLCompileUnitAST &package_ast)
1115
{
1116
  int ret = OB_SUCCESS;
1117
  CK (OB_LIKELY(T_SP_CREATE_TYPE_SRC == parse_tree->type_));
1118
  const ParseNode *spec_body_node = parse_tree;
1119
  CK (OB_NOT_NULL(spec_body_node));
1120
  if (OB_SUCC(ret)) {
1121
    // bool replace = static_cast<bool>(parse_tree->int32_values_[0]);
1122
    // bool noneditioable = static_cast<bool>(parse_tree->int32_values_[1]);
1123
    const ParseNode *name_node = spec_body_node->children_[0];
1124
    const ParseNode *oid_node = spec_body_node->children_[1];
1125
    const ParseNode *object_type_node = spec_body_node->children_[2];
1126

1127
    UNUSED(oid_node);
1128
    CK (OB_NOT_NULL(name_node));
1129
    CK (OB_NOT_NULL(object_type_node));
1130
    if (OB_SUCC(ret)) {
1131
      ObString db_name, udt_name;
1132
      if (OB_FAIL(ObResolverUtils::resolve_sp_name(get_resolve_ctx().session_info_,
1133
                                                  *name_node,
1134
                                                  db_name,
1135
                                                  udt_name))) {
1136
        LOG_WARN("failed to resolve type name", K(ret));
1137
      } else {
1138
        CK (T_SP_OBJECT_DEF == object_type_node->type_
1139
          || T_SP_OPAQUE_DEF == object_type_node->type_);
1140
        CK (OB_LIKELY(5 == object_type_node->num_child_));
1141
        CK (OB_NOT_NULL(object_type_node->children_[3]));
1142
        CK (OB_NOT_NULL(object_type_node->children_[1]));
1143
        if (OB_SUCC(ret)) {
1144
          // const ParseNode* invoke_accessby_node = object_type_node->children_[0];
1145
          const ParseNode* object_or_under = object_type_node->children_[1];
1146
          // const ParseNode* sqlj_node = object_type_node->children_[2];
1147
          const ParseNode* attrs_node = object_type_node->children_[3];
1148
          // const ParseNode* final_node = object_type_node->children_[4];
1149
          CK (OB_NOT_NULL(object_or_under));
1150
          CK (OB_NOT_NULL(attrs_node));
1151
          CK (OB_LIKELY(T_SP_OBJ_ATTR_AND_ELEMENT_SPEC == attrs_node->type_));
1152
          const ParseNode *elem_spec_list = attrs_node->children_[1];
1153
          if (OB_SUCC(ret)) {
1154
            if (T_SP_IS_UNDER_OBJECT == object_or_under->type_) {
1155
              ret = OB_NOT_SUPPORTED;
1156
              LOG_WARN("not support yet", K(ret));
1157
              LOG_USER_ERROR(OB_NOT_SUPPORTED, "under object");
1158
            } else if (OB_NOT_NULL(elem_spec_list)) {
1159
              if (OB_FAIL(resolve_object_elem_spec_list(elem_spec_list, package_ast))){
1160
                LOG_WARN("failed to resolve elem spec list", K(ret));
1161
              }
1162
            }
1163
          }
1164
        }
1165
      }
1166
    }
1167
  }
1168

1169
  return ret;
1170
}
1171

1172
int ObPLResolver::resolve_object_elem_spec_list(const ParseNode *parse_tree,
1173
                                                ObPLCompileUnitAST &package_ast)
1174
{
1175
  int ret = OB_SUCCESS;
1176
  const ParseNode* element_spec_list = parse_tree;
1177
  if (OB_ISNULL(element_spec_list)) {
1178
    ret = OB_ERR_UNEXPECTED;
1179
  } else {
1180
    for (int64_t i = 0; OB_SUCC(ret) && i < element_spec_list->num_child_; ++i) {
1181
      const ParseNode *element_spec = element_spec_list->children_[i];
1182
      if (OB_FAIL(resolve_object_elem_spec_def(element_spec, package_ast))) {
1183
        LOG_WARN("failed to resolve type spec", K(ret));
1184
      }
1185
    }
1186
  }
1187
  return ret;
1188
}
1189

1190
int ObPLResolver::resolve_object_elem_spec_def(const ParseNode *parse_tree,
1191
                                               ObPLCompileUnitAST &package_ast)
1192
{
1193
  int ret = OB_SUCCESS;
1194

1195
  CK (OB_NOT_NULL(parse_tree));
1196
  if (OB_SUCC(ret)) {
1197
    if (T_SP_OBJ_ELEMENT_SPEC == parse_tree->type_) {
1198
      CK (3 == parse_tree->num_child_);
1199
      // const ParseNode *inherit_node = parse_tree->children_[0];
1200
      const ParseNode *subprog_node = parse_tree->children_[1];
1201
      // const ParseNode *restrict_ref_node = parse_tree->children_[2];
1202
      if (OB_NOT_NULL(subprog_node)) {
1203
        if (T_SP_OBJ_ELEM_SUBPROG_SPEC == subprog_node->type_) {
1204
          const ParseNode *routine_node = subprog_node->children_[0];
1205
          CK (OB_NOT_NULL(routine_node));
1206
          if (OB_SUCC(ret)) {
1207
            int64_t member_or_static = static_cast<int64_t>(subprog_node->int16_values_[0]);
1208
            ObPLRoutineInfo *routine_info = NULL;
1209

1210
            if (OB_FAIL(resolve_routine_decl(routine_node, package_ast, routine_info, true))) {
1211
              LOG_WARN("failed to resolve object function", K(ret));
1212
            } else if (OB_ISNULL(routine_info)) {
1213
              ret = OB_ERR_UNEXPECTED;
1214
              LOG_WARN("udt routine info is null", K(ret));
1215
            } else {
1216
              if (UdtUdfType::UDT_UDF_STATIC == member_or_static) {
1217
                routine_info->get_compile_flag().add_static();
1218
              }
1219
              routine_info->set_is_udt_routine();
1220
              // check static and self
1221
              if (routine_info->is_udt_static_routine() && routine_info->has_self_param()) {
1222
                ret = OB_ERR_STATIC_METHOD_HAS_SELF;
1223
                LOG_WARN("static member routine should not have self param");
1224
              }
1225
            }
1226
          }
1227
        } else if (T_SP_OBJ_ELEM_CONSTRUCTOR == subprog_node->type_) {
1228
          ObPLRoutineInfo *routine_info = NULL;
1229
          // 0: name, 1 : param, 2 : attr
1230
          OZ (resolve_object_constructor(subprog_node, package_ast, routine_info));
1231
          CK (OB_NOT_NULL(routine_info));
1232
          if (OB_SUCC(ret)) {
1233
            routine_info->set_is_udt_routine();
1234
            routine_info->set_is_udt_cons();
1235
          }
1236
        } else if (T_SP_OBJ_MAP_ORDER == subprog_node->type_) {
1237
          ObPLRoutineInfo *routine_info = NULL;
1238
          const ParseNode *routine_node = subprog_node->children_[0];
1239
          CK (OB_NOT_NULL(routine_node));
1240
          OZ (resolve_routine_decl(routine_node, package_ast, routine_info, true));
1241
          CK (OB_NOT_NULL(routine_info));
1242
          OX (routine_info->set_is_udt_routine());
1243
        } else {
1244
          ret = OB_ERR_UNEXPECTED;
1245
          LOG_WARN("unknown type subprogram type", K(ret));
1246
        }
1247
      }
1248
    } else if (T_SP_OBJ_ELEM_CONSTRUCTOR == parse_tree->type_) {
1249
      ObPLRoutineInfo *routine_info = NULL;
1250
      OZ (resolve_object_constructor(parse_tree, package_ast, routine_info));
1251
      OV (OB_NOT_NULL(routine_info), OB_ERR_UNEXPECTED);
1252
      if (OB_SUCC(ret)) {
1253
        routine_info->set_is_udt_routine();
1254
        routine_info->set_is_udt_cons();
1255
      }
1256
    }
1257
    // inherit and restrict ref not support yet
1258
  }
1259

1260
  return ret;
1261
}
1262

1263
int ObPLResolver::resolve_object_constructor(const ParseNode *parse_tree,
1264
                                             ObPLCompileUnitAST &package_ast,
1265
                                             ObPLRoutineInfo *&routine_info)
1266
{
1267
  int ret = OB_SUCCESS;
1268
  ParseNode *subp = const_cast<ParseNode *>(parse_tree);
1269
  CK (OB_NOT_NULL(parse_tree));
1270
  CK (5 == parse_tree->num_child_);
1271
  CK (T_SP_OBJ_ELEM_CONSTRUCTOR == parse_tree->type_);
1272
  OX (subp->type_ = T_SUB_FUNC_DECL);
1273
  OZ (resolve_routine_decl(subp, package_ast, routine_info, true));
1274
  return ret;
1275
}
1276
#endif
1277

1278
int ObPLResolver::check_declare_order(ObPLStmtType type)
1279
{
1280
  int ret = OB_SUCCESS;
1281
  CK(PL_VAR == type || PL_COND == type || PL_HANDLER == type || PL_CURSOR == type);
1282
  if (is_oracle_mode()) {
1283
    // oracle compatible, do nothing ...
1284
  } else {
1285
    ObPLStmtType pre_type = INVALID_PL_STMT;
1286
    if (OB_NOT_NULL(current_block_) && (current_block_->get_stmts().count() != 0)) {
1287
      pre_type =
1288
        current_block_->get_stmts().at(current_block_->get_stmts().count() - 1)->get_type();
1289
    }
1290
    if (handler_analyzer_.get_stack_depth() > 0) {
1291
      ObPLDeclareHandlerStmt::DeclareHandler info;
1292
      if (OB_FAIL(handler_analyzer_.get_handler(handler_analyzer_.get_stack_depth() - 1, info))) {
1293
        LOG_WARN("failed to get last handler", K(ret));
1294
      } else if (info.get_level() == current_level_) {
1295
        pre_type = PL_HANDLER;
1296
      }
1297
    }
1298
    if (OB_FAIL(ret)) {
1299
    } else if ((PL_VAR == type || PL_COND == type)
1300
        && (PL_HANDLER == pre_type || PL_CURSOR == pre_type)) {
1301
      ret = OB_ER_SP_VARCOND_AFTER_CURSHNDLR;
1302
      LOG_USER_ERROR(OB_ER_SP_VARCOND_AFTER_CURSHNDLR);
1303
      LOG_WARN("Variable or condition declaration after cursor or handler declaration", K(ret));
1304
    } else if (PL_CURSOR == type && PL_HANDLER == pre_type) {
1305
      ret = OB_ER_SP_CURSOR_AFTER_HANDLER;
1306
      LOG_USER_ERROR(OB_ER_SP_CURSOR_AFTER_HANDLER);
1307
      LOG_WARN("Cursor declaration after handler declaration", K(ret));
1308
    }
1309
  }
1310
  return ret;
1311
}
1312

1313
#ifdef OB_BUILD_ORACLE_PL
1314
int ObPLResolver::resolve_declare_user_type(const ObStmtNodeTree *parse_tree, ObPLDeclareUserTypeStmt *stmt, ObPLFunctionAST &func)
1315
{
1316
  int ret = OB_SUCCESS;
1317
  ObPLCompileUnitAST &unit_ast = static_cast<ObPLCompileUnitAST&>(func);
1318
  ret = resolve_declare_user_type_comm(parse_tree, stmt, unit_ast);
1319
  return ret;
1320
}
1321

1322
int ObPLResolver::resolve_declare_user_type(const ObStmtNodeTree *parse_tree, ObPLPackageAST &package_ast)
1323
{
1324
  int ret = OB_SUCCESS;
1325
  ObPLCompileUnitAST &unit_ast = static_cast<ObPLCompileUnitAST&>(package_ast);
1326
  ret = resolve_declare_user_type_comm(parse_tree, NULL, unit_ast);
1327
  return ret;
1328
}
1329
#endif
1330

1331
int ObPLResolver::get_number_literal_value(ObRawExpr *expr, int64_t &result)
1332
{
1333
  int ret = OB_SUCCESS;
1334
  CK (OB_NOT_NULL(expr));
1335

1336
#define GET_CONST_EXPR_VAL(expr, result) \
1337
  const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(expr); \
1338
  CK (OB_NOT_NULL(const_expr)); \
1339
  CK (const_expr->get_value().is_integer_type() || const_expr->get_value().is_number()); \
1340
  if (OB_FAIL(ret)) { \
1341
  } else if (const_expr->get_value().is_integer_type()) { \
1342
    result = const_expr->get_value().get_int(); \
1343
  } else if (const_expr->get_value().is_number()) { \
1344
    OZ (const_expr->get_value().get_number().extract_valid_int64_with_trunc(result)); \
1345
  }
1346

1347
  if (OB_FAIL(ret)) {
1348
  } else if ((T_INT != expr->get_expr_type()
1349
       && T_OP_NEG != expr->get_expr_type())
1350
      || (T_OP_NEG == expr->get_expr_type()
1351
          && T_INT != expr->get_param_expr(0)->get_expr_type())) {
1352
    ret = OB_ERR_NUMERIC_LITERAL_REQUIRED;
1353
    LOG_WARN("PLS-00491: numeric literal required", K(ret), KPC(expr));
1354
  } else if (T_INT == expr->get_expr_type()) {
1355
    GET_CONST_EXPR_VAL(expr, result);
1356
  } else if (T_OP_NEG == expr->get_expr_type()) {
1357
    GET_CONST_EXPR_VAL(expr->get_param_expr(0), result);
1358
    OX (result = (INT64_MIN == result) ? static_cast<uint64_t>(INT64_MAX + 1UL) : -result);
1359
  } else {
1360
    ret = OB_ERR_UNEXPECTED;
1361
    LOG_WARN("unexpected expr type", K(ret), K(expr->get_expr_type()));
1362
  }
1363

1364
  return ret;
1365
}
1366

1367
int ObPLResolver::get_const_number_variable_literal_value(ObRawExpr *expr, int64_t &result)
1368
{
1369
  int ret = OB_SUCCESS;
1370
  CK (OB_NOT_NULL(expr));
1371
  CK (T_QUESTIONMARK == expr->get_expr_type());
1372
  CK (OB_NOT_NULL(current_block_));
1373
  CK (OB_NOT_NULL(current_block_->get_symbol_table()));
1374

1375
  if (OB_SUCC(ret)) {
1376
    int64_t idx = static_cast<ObConstRawExpr*>(expr)->get_value().get_unknown();
1377
    const ObPLVar *var = current_block_->get_symbol_table()->get_symbol(idx);
1378

1379
    const ObRawExpr *value_expr = nullptr;
1380

1381
    if (OB_ISNULL(var)) {
1382
      ret = OB_ERR_UNEXPECTED;
1383
      LOG_WARN("unexpected NULL symbol variable", K(ret), KPC(expr),
1384
               K(current_block_->get_symbol_table()), K(idx));
1385
    } else if (!var->is_readonly()
1386
               || OB_ISNULL(value_expr = current_block_->get_expr(var->get_default()))
1387
               || (T_NUMBER != value_expr->get_expr_type() && T_INT != value_expr->get_expr_type())) {
1388
      ret = OB_ERR_NUMERIC_LITERAL_REQUIRED;
1389
      LOG_WARN("PLS-00491: numeric literal required", K(ret), K(var), K(value_expr));
1390
    } else {
1391
      GET_CONST_EXPR_VAL(value_expr, result);
1392
    }
1393
  }
1394

1395
#undef GET_CONST_EXPR_VAL
1396
  return ret;
1397
}
1398

1399
int ObPLResolver::calc_subtype_range_bound(const ObStmtNodeTree *bound_node,
1400
                                           ObPLCompileUnitAST &unit_ast,
1401
                                           int32_t &bound)
1402
{
1403
  int ret = OB_SUCCESS;
1404
  ObRawExpr *bound_expr = NULL;
1405
  int64_t result = -1;
1406
  CK (OB_NOT_NULL(bound_node));
1407
  OZ (resolve_expr(bound_node, unit_ast, bound_expr, combine_line_and_col(bound_node->stmt_loc_)));
1408
  CK (OB_NOT_NULL(bound_expr));
1409
  if (T_QUESTIONMARK == bound_expr->get_expr_type()){
1410
    OZ (get_const_number_variable_literal_value(bound_expr, result));
1411
  } else if (T_OP_NEG == bound_expr->get_expr_type()
1412
             && OB_NOT_NULL(bound_expr->get_param_expr(0))
1413
             && T_QUESTIONMARK == bound_expr->get_param_expr(0)->get_expr_type()) {
1414
    OZ (get_const_number_variable_literal_value(bound_expr->get_param_expr(0), result));
1415
    OX (result = (INT64_MIN == result) ? static_cast<uint64_t>(INT64_MAX + 1UL) : -result);
1416
  } else {
1417
    OZ (get_number_literal_value(bound_expr, result));
1418
  }
1419

1420
  if (OB_SUCC(ret)) {
1421
    if (-2147483648 <= result && result <= 2147483647) {
1422
      bound = result;
1423
    } else {
1424
      ret = OB_ERR_NON_INT_LITERAL;
1425
      LOG_WARN("PLS-00325: non-integral numeric literal string is inappropriate in this context",
1426
               K(ret), K(result));
1427
    }
1428
  }
1429
  return ret;
1430
}
1431

1432
#ifdef OB_BUILD_ORACLE_PL
1433
int ObPLResolver::resolve_subtype_precision(const ObStmtNodeTree *precision_node,
1434
                                            ObPLDataType &base_type)
1435
{
1436
  int ret = OB_SUCCESS;
1437
  int16_t precision = -1;
1438
  int16_t scale = 0;
1439
  CK (OB_NOT_NULL(precision_node));
1440
  CK (T_LINK_NODE == precision_node->type_);
1441
  CK (1 == precision_node->param_num_ || 2 == precision_node->param_num_);
1442
  OX (precision = precision_node->int16_values_[0]);
1443
  OX (2 == precision_node->param_num_ ? scale = precision_node->int16_values_[1] : int16_t(0));
1444
  CK (OB_NOT_NULL(base_type.get_data_type()));
1445
  if (OB_SUCC(ret)) {
1446
    ObObjTypeClass tclass = base_type.get_data_type()->get_type_class();
1447
    if (2 == precision_node->param_num_) {
1448
      if (ObNumberTC != tclass) {
1449
        ret = OB_NOT_SUPPORTED;
1450
        LOG_WARN("not supported yet", K(ret), K(tclass));
1451
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "precision of subtype is non-number type");
1452
      }
1453
    } else {
1454
      if (ObFloatTC != tclass && ObDoubleTC != tclass && ObStringTC != tclass
1455
          && ObNumberTC != tclass && ObOTimestampTC != tclass) {
1456
        ret = OB_NOT_SUPPORTED;
1457
        LOG_WARN("not supported yet", K(ret), K(tclass));
1458
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "the base type of subtype is not float/double/string/number/timestamp class");
1459
      }
1460
    }
1461
    if (OB_SUCC(ret)) {
1462
      if (ObOTimestampTC == tclass) {
1463
        if (precision > OB_MAX_TIMESTAMP_TZ_PRECISION) {
1464
          ret = OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE;
1465
        } else {
1466
          base_type.get_data_type()->set_precision(precision);
1467
          base_type.get_data_type()->set_scale(scale);
1468
        }
1469
      } else if (ObNumberTC == tclass) {
1470
        if (base_type.get_data_type()->get_meta_type().is_number_float()) {
1471
          if ((OB_UNLIKELY(precision < OB_MIN_NUMBER_FLOAT_PRECISION)
1472
                  || OB_UNLIKELY(precision > OB_MAX_NUMBER_FLOAT_PRECISION))) {
1473
            ret = OB_FLOAT_PRECISION_OUT_RANGE;
1474
            LOG_WARN("precision of float out of range", K(ret), K(precision));
1475
          }
1476
        } else if ((OB_UNLIKELY(precision < OB_MIN_NUMBER_PRECISION)
1477
                    || OB_UNLIKELY(precision > OB_MAX_NUMBER_PRECISION))) {
1478
          ret = OB_NUMERIC_PRECISION_OUT_RANGE;
1479
          LOG_WARN("precision of number overflow", K(ret), K(scale), K(precision));
1480
        } else if (OB_UNLIKELY(scale < OB_MIN_NUMBER_SCALE)
1481
                   || OB_UNLIKELY(scale > OB_MAX_NUMBER_SCALE)) {
1482
          ret = OB_NUMERIC_SCALE_OUT_RANGE;
1483
          LOG_WARN("scale of number out of range", K(ret), K(scale));
1484
        } else {
1485
          base_type.get_data_type()->set_precision(precision);
1486
          base_type.get_data_type()->set_scale(scale);
1487
        }
1488
      } else if (ObFloatTC == tclass || ObDoubleTC == tclass) {
1489
        base_type.get_data_type()->set_precision(precision);
1490
        base_type.get_data_type()->set_scale(scale);
1491
      } else if (ObStringTC == tclass) {
1492
        if (0 == precision) {
1493
          ret = OB_ERR_ZERO_LEN_COL;
1494
          LOG_WARN("Oracle not allowed zero length", K(ret));
1495
          // @FIXME comparison is always false due to limited range of data type
1496
_Pragma("GCC diagnostic push")
1497
_Pragma("GCC diagnostic ignored \"-Wtype-limits\"")
1498
        } else if (OB_MAX_ORACLE_VARCHAR_LENGTH < precision || precision < 0) {
1499
_Pragma("GCC diagnostic pop")
1500
          ret = OB_ERR_TOO_LONG_COLUMN_LENGTH;
1501
          LOG_WARN("column data length is invalid", K(ret), K(precision), K(base_type));
1502
        } else {
1503
          base_type.get_data_type()->set_length(precision);
1504
        }
1505
      } else {
1506
        ret = OB_ERR_UNEXPECTED;
1507
        LOG_WARN("not supported yet", K(ret), K(base_type));
1508
        LOG_USER_ERROR(OB_ERR_UNEXPECTED, "type class");
1509
      }
1510
    }
1511
  }
1512
  return ret;
1513
}
1514

1515
int ObPLResolver::resolve_declare_user_subtype(const ObStmtNodeTree *parse_tree,
1516
                                               ObPLDeclareUserTypeStmt *stmt,
1517
                                               ObPLCompileUnitAST &unit_ast)
1518
{
1519
  int ret = OB_SUCCESS;
1520
  ObString subtype_name;
1521
  bool not_null = false;
1522
  bool has_range = false;
1523
  int32_t lower = -1;
1524
  int32_t upper = -1;
1525
  ObPLDataType base_type;
1526
  const ObStmtNodeTree *name_node = NULL;
1527
  const ObStmtNodeTree *type_node = NULL;
1528
  const ObStmtNodeTree *constraint_node = NULL;
1529
  // 合法性检查
1530
  CK (OB_NOT_NULL(parse_tree));
1531
  CK (OB_NOT_NULL(current_block_));
1532
  CK (OB_LIKELY(T_SP_DECL_USER_SUBTYPE == parse_tree->type_));
1533
  CK (OB_LIKELY(2 == parse_tree->num_child_));
1534
  CK (OB_NOT_NULL(parse_tree->children_[0])
1535
      && OB_LIKELY(T_IDENT == parse_tree->children_[0]->type_));
1536
  CK (OB_NOT_NULL(name_node = parse_tree->children_[0]));
1537
  CK (OB_NOT_NULL(type_node = parse_tree->children_[1]));
1538
  CK (T_SP_USER_SUBTYPE_BASETYPE == type_node->type_);
1539
  CK (2 == type_node->num_child_);
1540
  OX (constraint_node = type_node->children_[1]);
1541
  CK (OB_NOT_NULL(type_node = type_node->children_[0]));
1542
  // 解析子类型名称
1543
  OX (subtype_name = ObString(name_node->str_len_, name_node->str_value_));
1544
  // 解析子类型的基础类型
1545
  CK (OB_NOT_NULL(type_node));
1546
  OZ (resolve_sp_data_type(type_node, subtype_name, unit_ast, base_type, NULL));
1547
  // 解析子类型的RANGE子句
1548
  if (OB_SUCC(ret) && OB_NOT_NULL(constraint_node)) {
1549
    if (T_SP_USER_SUBTYPE_RANGE == constraint_node->type_) {
1550
      CK (OB_LIKELY(2 == constraint_node->num_child_));
1551
      CK (OB_NOT_NULL(constraint_node->children_[0]));
1552
      CK (OB_NOT_NULL(constraint_node->children_[1]));
1553
      OZ (calc_subtype_range_bound(constraint_node->children_[0], unit_ast, lower));
1554
      OZ (calc_subtype_range_bound(constraint_node->children_[1], unit_ast, upper));
1555
      if (OB_SUCC(ret)) {
1556
        if (!base_type.is_pl_integer_type() || upper < lower) {
1557
          ret = OB_ERR_IMPROPER_CONSTRAINT_FORM;
1558
          LOG_WARN("PLS-00572: improper constraint form used", K(ret), K(base_type));
1559
        }
1560
      }
1561
      OX (has_range = true);
1562
    } else {
1563
      CK (T_LINK_NODE == constraint_node->type_);
1564
      OZ (resolve_subtype_precision(constraint_node, base_type));
1565
    }
1566
  }
1567
  // 解析NOT NULL子句
1568
  OX (not_null = (-1 == parse_tree->value_) ? false : static_cast<bool>(parse_tree->value_));
1569
  // 构造并加入NameSpace
1570
  if (OB_SUCC(ret)) {
1571
    ObUserDefinedSubType *subtype = NULL;
1572
    if (OB_ISNULL(subtype = static_cast<ObUserDefinedSubType *>
1573
                  (resolve_ctx_.allocator_.alloc(sizeof(ObUserDefinedSubType))))) {
1574
      ret = OB_ALLOCATE_MEMORY_FAILED;
1575
      LOG_WARN("failed to alloc memory for user defiend sub type", K(ret));
1576
    }
1577
    OX (subtype = new(subtype)ObUserDefinedSubType());
1578
    OX (subtype->set_name(subtype_name));
1579
    CK (!base_type.is_subtype());
1580

1581
    if (OB_SUCC(ret)) {
1582
      if (base_type.is_not_null() && -1 == parse_tree->value_) {
1583
        ret = OB_ERR_SUBTYPE_NOTNULL_MISMATCH;
1584
        LOG_WARN("PLS-00366: subtype of a not null type must also be not null", K(ret));
1585
      } else {
1586
        OX (base_type.set_not_null(not_null || base_type.get_not_null()));
1587
      }
1588
    }
1589
    OX (has_range ? base_type.set_range(lower, upper) : void(NULL));
1590
    OX (subtype->set_base_type(base_type));
1591
    OZ (current_block_->get_namespace().add_type(subtype));
1592
    OX (NULL != stmt ? stmt->set_user_type(subtype) : (void)NULL);
1593
  }
1594
  return ret;
1595
}
1596

1597
int ObPLResolver::resolve_declare_user_type_comm(const ObStmtNodeTree *parse_tree,
1598
                                                 ObPLDeclareUserTypeStmt *stmt,
1599
                                                 ObPLCompileUnitAST &unit_ast)
1600
{
1601
  int ret = OB_SUCCESS;
1602
  const ObStmtNodeTree *type_definition_node = NULL;
1603
  if (OB_ISNULL(parse_tree) || OB_ISNULL(current_block_)) {
1604
    ret = OB_INVALID_ARGUMENT;
1605
    LOG_WARN("invalid argument", K(parse_tree), K(stmt));
1606
  } else if (OB_ISNULL(type_definition_node = parse_tree->children_[0])) {
1607
    ret = OB_ERR_UNEXPECTED;
1608
    LOG_WARN("type definition node is null");
1609
  } else {
1610
    switch (type_definition_node->type_) {
1611
    case T_SP_REF_CURSOR_TYPE: {
1612
      if (OB_FAIL(resolve_ref_cursor_type(type_definition_node, stmt, unit_ast))) {
1613
        LOG_WARN("resolve declare ref cursor type failed", K(ret));
1614
      }
1615
    }
1616
      break;
1617
    case T_SP_RECORD_TYPE: {
1618
      //record type
1619
      if (OB_FAIL(resolve_declare_record_type(type_definition_node, stmt, unit_ast))) {
1620
        LOG_WARN("resolve declare record type failed", K(ret));
1621
      }
1622
    }
1623
      break;
1624
    case T_SP_COLLECTION_TYPE: {
1625
      //collection type
1626
      if (OB_FAIL(resolve_declare_collection_type(type_definition_node, stmt, unit_ast))) {
1627
        LOG_WARN("resolve declare collection type failed", K(ret));
1628
      }
1629
    }
1630
      break;
1631
    default: {
1632
      ret = OB_ERR_UNEXPECTED;
1633
      LOG_WARN("invalid type node", K_(type_definition_node->type));
1634
    }
1635
      break;
1636
    }
1637
  }
1638
  return ret;
1639
}
1640

1641
int ObPLResolver::resolve_ref_cursor_type(const ParseNode *node,
1642
                                              ObPLDeclareUserTypeStmt *stmt,
1643
                                              ObPLCompileUnitAST &unit_ast)
1644
{
1645
  int ret = OB_SUCCESS;
1646
  if (OB_ISNULL(node) || OB_ISNULL(current_block_)) { //如果是package，stmt为空，所以这里不检查stmt
1647
    ret = OB_INVALID_ARGUMENT;
1648
    LOG_WARN("parse_tree is NULL", K(node), K(stmt), K(current_block_), K(ret));
1649
  } else {
1650
    //解析name
1651
    const ObStmtNodeTree *name_node = node->children_[0];
1652
    const ObStmtNodeTree *type_node = node->children_[1];
1653
    if (OB_ISNULL(name_node)) {
1654
      ret = OB_ERR_UNEXPECTED;
1655
      LOG_WARN("parse_tree is NULL", K(name_node), K(ret));
1656
    } else {
1657
      ObString name;
1658
      ObPLDataType return_type;
1659
      if (OB_FAIL(resolve_cursor_common(name_node, type_node, unit_ast, name, return_type))) {
1660
        LOG_WARN("failed to resolve cursor comm", K(ret), K(name));
1661
      } else if (NULL != type_node && !return_type.is_record_type()) {
1662
        ret = OB_ERR_INVALID_CURSOR_RETURN_TYPE;
1663
        LOG_WARN("ref cursor must return record type", K(return_type), K(ret));
1664
      } else {
1665
        ObRefCursorType *ref_cursor_type = NULL;
1666
        if (OB_ISNULL(ref_cursor_type = static_cast<ObRefCursorType*>(resolve_ctx_.allocator_.alloc(sizeof(ObRefCursorType))))) {
1667
          ret = OB_ALLOCATE_MEMORY_FAILED;
1668
          LOG_WARN("failed to alloc memory", K(ret));
1669
        } else {
1670
          ref_cursor_type = new(ref_cursor_type)ObRefCursorType();
1671
          ref_cursor_type->set_name(name);
1672
          if (unit_ast.is_package()) {
1673
            ref_cursor_type->set_type_from(PL_TYPE_PACKAGE);
1674
          }
1675
          NULL == type_node ? (void)NULL : ref_cursor_type->set_return_type_id(return_type.get_user_type_id());
1676
          if (OB_FAIL(current_block_->get_namespace().add_type(ref_cursor_type))) {
1677
            LOG_WARN("failed to add record type to type table", K(*ref_cursor_type), K(ret));
1678
          } else if (!OB_ISNULL(stmt)) {
1679
            stmt->set_user_type(static_cast<ObUserDefinedType *>(ref_cursor_type));
1680
          } else { /*do nothing*/ }
1681
        }
1682
      }
1683
    }
1684
  }
1685
  return ret;
1686
}
1687
#endif
1688

1689
int ObPLResolver::resolve_declare_record_type(const ParseNode *type_node,
1690
                                              ObPLDeclareUserTypeStmt *stmt,
1691
                                              ObPLCompileUnitAST &unit_ast)
1692
{
1693
  int ret = OB_SUCCESS;
1694
  if (OB_ISNULL(type_node)) {
1695
    ret = OB_INVALID_ARGUMENT;
1696
    LOG_WARN("type_node is null");
1697
  } else if (OB_UNLIKELY(type_node->num_child_ != 2)) {
1698
    ret = OB_ERR_UNEXPECTED;
1699
    LOG_WARN("type node children number is invalid", K_(type_node->num_child));
1700
  } else {
1701
    //resolve record name
1702
    const ParseNode *name_node = type_node->children_[0];
1703
    ObString record_name;
1704
    if (OB_ISNULL(name_node)) {
1705
      ret = OB_ERR_UNEXPECTED;
1706
      LOG_WARN("name node is null");
1707
    } else {
1708
      record_name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));
1709
    }
1710
    //resolve record member list
1711
    if (OB_SUCC(ret)) {
1712
      ObRecordType *record_type = NULL;
1713
      const ParseNode *record_member_list = NULL;
1714
      void *ptr = NULL;
1715
      if (OB_ISNULL(record_member_list = type_node->children_[1])) {
1716
        ret = OB_ERR_UNEXPECTED;
1717
        LOG_WARN("record_member_list is null");
1718
      } else if (OB_UNLIKELY(record_member_list->type_ != T_RECORD_MEMBER_LIST)) {
1719
        ret = OB_ERR_UNEXPECTED;
1720
        LOG_WARN("record member list is invalid", K_(record_member_list->type));
1721
      } else if (OB_ISNULL(ptr = resolve_ctx_.allocator_.alloc(sizeof(ObRecordType)))) {
1722
        ret = OB_ALLOCATE_MEMORY_FAILED;
1723
        LOG_WARN("allocate memory failed", K(ret));
1724
      } else {
1725
        record_type = new(ptr) ObRecordType();
1726
        record_type->set_name(record_name);
1727
        if (unit_ast.is_package()) {
1728
          record_type->set_type_from(PL_TYPE_PACKAGE);
1729
        }
1730
      }
1731

1732
      ObPLStmtBlock *parent = current_block_;
1733
      ObPLBlockNS *parent_namespace = resolve_ctx_.params_.secondary_namespace_;
1734
      ObPLStmtBlock *block = NULL;
1735
      if (unit_ast.is_routine()) {
1736
        OZ (make_block(static_cast<ObPLFunctionAST&>(unit_ast), parent, block, false));
1737
      } else {
1738
        OZ (make_block(static_cast<ObPLPackageAST&>(unit_ast), block));
1739
        OX (block->get_namespace().set_block_type(ObPLBlockNS::BLOCK_ROUTINE));
1740
        OX (block->get_namespace().set_pre_ns(NULL == parent ? NULL : &parent->get_namespace()));
1741
      }
1742
      OX (set_current(*block));
1743
      CK (OB_NOT_NULL(record_type));
1744
      OZ (record_type->record_members_init(&resolve_ctx_.allocator_, record_member_list->num_child_));
1745
      for (int64_t i = 0; OB_SUCC(ret) && i < record_member_list->num_child_; ++i) {
1746
        const ParseNode *member_node = record_member_list->children_[i];
1747
        if (OB_ISNULL(member_node)) {
1748
          ret = OB_ERR_UNEXPECTED;
1749
          LOG_WARN("member_node is null");
1750
        } else if (OB_UNLIKELY(member_node->type_ != T_RECORD_MEMBER)) {
1751
          ret = OB_ERR_UNEXPECTED;
1752
          LOG_WARN("member node is null");
1753
        } else if (OB_UNLIKELY(3 != member_node->num_child_)) {
1754
          ret = OB_ERR_UNEXPECTED;
1755
          LOG_WARN("member node children number is invalid", K(member_node->num_child_));
1756
        } else {
1757
          ObString member_name(static_cast<int32_t>(member_node->children_[0]->str_len_), member_node->children_[0]->str_value_);
1758
          ObPLDataType data_type;
1759
          ObRawExpr *default_expr = NULL;
1760
          ParseNode *default_node = member_node->children_[2];
1761
          bool member_not_null = (1 == member_node->int32_values_[0]);
1762
          if (OB_FAIL(resolve_sp_data_type(member_node->children_[1], record_name, unit_ast, data_type))) {
1763
            LOG_WARN("resolve sp data type failed", K(ret));
1764
          } else if (data_type.is_cursor_type()) {
1765
            ret = OB_NOT_SUPPORTED;
1766
            LOG_WARN("Cursor type defined in record is not supported", K(ret));
1767
            LOG_USER_ERROR(OB_NOT_SUPPORTED, "attribute type of record is cursor type");
1768
          } else if (OB_FAIL(current_block_->get_namespace().add_symbol(
1769
                          member_name, data_type, NULL, false, false, false, true))) {
1770
            LOG_WARN("failed to add symbol to namespace", K(ret), K(member_name));
1771
          } else {
1772
            // subtype may have not null declared, check it first, etc. subtype t1 is int not null;
1773
            if (OB_SUCC(ret)) {
1774
              if (data_type.is_not_null() && -1 == member_node->int32_values_[0]) {
1775
                ret = OB_ERR_SUBTYPE_NOTNULL_MISMATCH;
1776
                LOG_WARN("PLS-00366: subtype of a not null type must also be not null", K(ret));
1777
              } else {
1778
                member_not_null = data_type.get_not_null() ? true : member_not_null;
1779
              }
1780
            }
1781
            if (OB_SUCC(ret)) {
1782
              data_type.set_not_null(member_not_null);
1783
              int64_t default_expr_idx = OB_INVALID_INDEX;
1784
              // not null不能是空值，但是这个只能防住 a not null这种情况， a not null := null这种防不住
1785
              // 所以在record的generate_default_value里面增加了null check
1786
              if ((member_not_null) && OB_ISNULL(default_node)) {
1787
                ret = OB_ERR_INIT_NOTNULL_ILLEGAL;
1788
                LOG_WARN("not null member does not dafault value", K(ret));
1789
              } else {
1790
                if (OB_NOT_NULL(default_node)) {
1791
                  ObRawExpr *new_default_expr = NULL;
1792
                  OZ (resolve_expr(default_node, unit_ast, default_expr,
1793
                                  combine_line_and_col(default_node->stmt_loc_), true, &data_type));
1794
                  OZ (check_param_default_expr_legal(default_expr, false));
1795
                  OX (new_default_expr = default_expr);
1796
                  OZ (replace_record_member_default_expr(new_default_expr));
1797
                  if (OB_SUCC(ret) && new_default_expr != default_expr) {
1798
                    OX (default_expr = new_default_expr);
1799
                    OZ (unit_ast.add_expr(new_default_expr));
1800
                  }
1801
                  OX (default_expr_idx = unit_ast.get_expr_count() - 1);
1802
                } else {
1803
                  /*
1804
                  To define a RECORD type, specify its name and define its fields. To define a field,
1805
                  specify its name and data type. By default, the initial value of a field is NULL
1806
                  */
1807
                  // 设置成invalid，后面赋值的时候发现是invalid，赋值为null
1808
                  default_expr_idx = OB_INVALID_INDEX;
1809
                }
1810
              }
1811
              if (OB_SUCC(ret)) {
1812
                if (OB_FAIL(record_type->add_record_member(member_name,
1813
                                                          data_type,
1814
                                                          default_expr_idx,
1815
                                                          default_expr))) {
1816
                  LOG_WARN("add record member failed", K(ret));
1817
                } else {
1818
                  record_type->set_not_null(record_type->get_not_null());
1819
                }
1820
              }
1821
            }
1822
          }
1823
        }
1824
      }
1825

1826
      if (OB_SUCC(ret) && OB_NOT_NULL(block)) {
1827
        OZ (block->get_namespace().delete_symbols());
1828
      }
1829
      if (OB_NOT_NULL(parent)) {
1830
        set_current(*parent);
1831
        resolve_ctx_.params_.secondary_namespace_ = parent_namespace;
1832
      }
1833

1834
      if (OB_SUCC(ret)) {
1835
        if (OB_ISNULL(current_block_)) {
1836
          ret = OB_ERR_UNEXPECTED;
1837
          LOG_WARN("current block is null");
1838
        } else if (OB_FAIL(current_block_->get_namespace().add_type(record_type))) {
1839
          LOG_WARN("failed to add record type to type table", K(*record_type), K(ret));
1840
        } else {
1841
          if (!OB_ISNULL(stmt)) {
1842
            stmt->set_user_type(static_cast<ObUserDefinedType *>(record_type));
1843
          }
1844
        }
1845
      }
1846
    }
1847
  }
1848
  return ret;
1849
}
1850

1851
#ifdef OB_BUILD_ORACLE_PL
1852
int ObPLResolver::resolve_sp_subtype_precision(ObSQLSessionInfo &sesion_info,
1853
                                               ObIArray<ObRawExpr*>& params,
1854
                                               const ObUserDefinedType *user_type,
1855
                                               ObPLDataType &pl_type)
1856
{
1857
  int ret = OB_SUCCESS;
1858
  int64_t precision = -1;
1859
  int64_t scale = -1;
1860
  const ObUserDefinedSubType *sub_type = NULL;
1861

1862
  CK (OB_NOT_NULL(user_type));
1863
  CK (params.count() > 0);
1864

1865
  if (OB_FAIL(ret)) {
1866
  } else if (!user_type->is_subtype()) {
1867
    ret = OB_ERR_TYPE_CANT_CONSTRAINED;
1868
    LOG_WARN("PLS-00566: type name \"string\" cannot be constrained", K(ret));
1869
  } else if (params.count() > 2) {
1870
    ret = OB_ERR_IMPROPER_CONSTRAINT_FORM;
1871
    LOG_WARN("PLS-00572: improper constraint form used", K(ret), K(params.count()));
1872
  }
1873
  for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
1874
    int64_t result = -1;
1875
    OZ (get_number_literal_value(params.at(i), result));
1876
    OX (0==i ? precision = result : scale = result);
1877
  }
1878
  CK (OB_NOT_NULL(sub_type = static_cast<const ObUserDefinedSubType *>(user_type)));
1879
  OX (pl_type = *(sub_type->get_base_type()));
1880
  if (OB_SUCC(ret)) {
1881
    if (OB_ISNULL(pl_type.get_data_type())) {
1882
      ret = OB_ERR_TYPE_CANT_CONSTRAINED;
1883
      LOG_WARN("PLS-00566: type name \"string\" cannot be constrained", K(ret), K(pl_type));
1884
    } else if (2 == params.count()
1885
              && pl_type.get_data_type()->get_type_class() != ObNumberTC) {
1886
      ret = OB_NOT_SUPPORTED;
1887
      LOG_WARN("only can specific scale for number type class",
1888
               K(ret), KPC(pl_type.get_data_type()));
1889
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "specific scale for non number type class");
1890
    }
1891
  }
1892

1893
  if (OB_SUCC(ret)) {
1894
    //reference by ObResolverUtils::resolve_data_type
1895
    ObDataType &data_type = (*pl_type.get_data_type());
1896
    const ObAccuracy &default_accuracy
1897
      = ObAccuracy::DDL_DEFAULT_ACCURACY2[true][data_type.get_obj_type()];
1898
    switch (data_type.get_type_class()) {
1899
      case ObIntTC:
1900
      case ObUIntTC: {
1901
        if (precision <= 0) {
1902
          precision = default_accuracy.get_precision();
1903
        }
1904
        if (precision > OB_MAX_INTEGER_DISPLAY_WIDTH) {
1905
          ret = OB_ERR_TOO_BIG_DISPLAYWIDTH;
1906
        } else {
1907
          data_type.set_precision(precision);
1908
          data_type.set_scale(0);
1909
        }
1910
      } break;
1911
      case ObFloatTC:
1912
      case ObDoubleTC: {
1913
        data_type.set_precision(precision);
1914
        data_type.set_scale(scale);
1915
        break;
1916
      }
1917
      case ObNumberTC: {
1918
        if (data_type.get_meta_type().is_number_float()) {
1919
          if (precision != PRECISION_UNKNOWN_YET
1920
            && (OB_UNLIKELY(precision < OB_MIN_NUMBER_FLOAT_PRECISION)
1921
                || OB_UNLIKELY(precision > OB_MAX_NUMBER_FLOAT_PRECISION))) {
1922
            ret = OB_FLOAT_PRECISION_OUT_RANGE;
1923
            LOG_WARN("precision of float out of range", K(ret), K(precision));
1924
          } else {
1925
            data_type.set_precision(precision);
1926
            data_type.set_scale(ORA_NUMBER_SCALE_UNKNOWN_YET);
1927
          }
1928
        } else if (OB_UNLIKELY(precision < OB_MIN_NUMBER_PRECISION)
1929
                   || OB_UNLIKELY(precision > OB_MAX_NUMBER_PRECISION)) {
1930
          ret = OB_NUMERIC_PRECISION_OUT_RANGE;
1931
          LOG_WARN("precision of number overflow", K(ret), K(scale), K(precision));
1932
        } else if (2 == params.count()
1933
                  && (OB_UNLIKELY(scale < OB_MIN_NUMBER_SCALE)
1934
                      || OB_UNLIKELY(scale > OB_MAX_NUMBER_SCALE))) {
1935
          ret = OB_NUMERIC_SCALE_OUT_RANGE;
1936
          LOG_WARN("scale of number out of range", K(ret), K(scale));
1937
        } else {
1938
          data_type.set_precision(precision);
1939
          if (2 == params.count()) {
1940
            data_type.set_scale(scale);
1941
          } else {
1942
            data_type.set_scale(0);
1943
          }
1944
        }
1945
      }  break;
1946
      case ObOTimestampTC: {
1947
        if (OB_UNLIKELY(precision > OB_MAX_TIMESTAMP_TZ_PRECISION)) {
1948
          ret = OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE;
1949
        } else {
1950
          data_type.set_precision(
1951
            static_cast<int16_t>(default_accuracy.get_precision() + precision));
1952
          data_type.set_scale(precision);
1953
        }
1954
      } break;
1955
      case ObStringTC: {
1956
        int32_t length = precision;
1957
        int64_t nchar_mbminlen = 0;
1958
        const ObSessionNLSParams &nls_session_param = sesion_info.get_session_nls_params();
1959
        data_type.set_length(length);
1960
        if (0 == length) {
1961
          ret = OB_ERR_ZERO_LEN_COL;
1962
          LOG_WARN("Oracle not allowed zero length", K(ret));
1963
        } else if (OB_FAIL(ObCharset::get_mbminlen_by_coll(
1964
          nls_session_param.nls_nation_collation_, nchar_mbminlen))) {
1965
          LOG_WARN("fail to get mbminlen of nchar", K(ret), K(nls_session_param));
1966
        } else if (((ObVarcharType == data_type.get_obj_type()
1967
                     || ObNVarchar2Type == data_type.get_obj_type())
1968
                      && OB_MAX_ORACLE_VARCHAR_LENGTH < length)
1969
                     || (ObCharType == data_type.get_obj_type()
1970
                         && OB_MAX_ORACLE_CHAR_LENGTH_BYTE < length)
1971
                     || (ObNCharType == data_type.get_obj_type()
1972
                         && OB_MAX_ORACLE_CHAR_LENGTH_BYTE < length * nchar_mbminlen)) {
1973
          ret = OB_ERR_TOO_LONG_COLUMN_LENGTH;
1974
          LOG_WARN("column data length is invalid",
1975
                   K(ret), K(length), K(data_type), K(nchar_mbminlen));
1976
        }
1977
      } break;
1978
      case ObRawTC:
1979
      case ObLobTC:
1980
      case ObTextTC:
1981
      case ObJsonTC:
1982
      case ObGeometryTC: {
1983
        data_type.set_length(precision);
1984
      } break;
1985
      case ObRowIDTC: {
1986
        if (ob_is_urowid(data_type.get_obj_type())) {
1987
          if (precision > OB_MAX_USER_ROW_KEY_LENGTH) {
1988
            ret = OB_ERR_TOO_LONG_COLUMN_LENGTH;
1989
            LOG_WARN("column data length is invalid", K(ret), K(precision), K(data_type));
1990
          } else {
1991
            data_type.set_length(precision);
1992
          }
1993
        } else {
1994
          ret = OB_NOT_SUPPORTED;
1995
          LOG_WARN("only support urowid type for now", K(ret), K(data_type));
1996
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "non-urowid type");
1997
        }
1998
      } break;
1999
      default: {
2000
        ret = OB_ERR_ILLEGAL_TYPE;
2001
        LOG_WARN("Unsupported data type for subtype basetype", K(ret), K(data_type));
2002
      } break;
2003
    }
2004
  }
2005
  return ret;
2006
}
2007
#endif
2008

2009
int ObPLResolver::resolve_sp_composite_type(const ParseNode *sp_data_type_node,
2010
                                            ObPLCompileUnitAST &func,
2011
                                            ObPLDataType &data_type,
2012
                                            ObPLExternTypeInfo *extern_type_info)
2013
{
2014
  int ret = OB_SUCCESS;
2015

2016
  ObArray<ObObjAccessIdent> obj_access_idents;
2017
  ObArray<ObObjAccessIdx> access_idxs;
2018
  const ObUserDefinedType *user_type = NULL;
2019
  ObArray<ObRawExpr*> params;
2020
  SET_LOG_CHECK_MODE();
2021
  CK (OB_NOT_NULL(sp_data_type_node));
2022
  CK (OB_NOT_NULL(current_block_));
2023
  CK (T_SP_OBJ_ACCESS_REF == sp_data_type_node->type_);
2024
  OZ (resolve_obj_access_idents(*(sp_data_type_node), obj_access_idents, func));
2025
  CK (obj_access_idents.count() > 0);
2026
  OX (obj_access_idents.at(obj_access_idents.count() - 1).has_brackets_ = false);
2027
  for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_idents.count(); ++i) {
2028
    OZ (resolve_access_ident(obj_access_idents.at(i),
2029
                             current_block_->get_namespace(),
2030
                             expr_factory_,
2031
                             &resolve_ctx_.session_info_,
2032
                             access_idxs,
2033
                             func));
2034
  }
2035
  if (OB_ERR_SP_UNDECLARED_VAR == ret) {
2036
    if (2 == sp_data_type_node->num_child_ 
2037
          && NULL != sp_data_type_node->children_[1]
2038
          && T_SP_CPARAM_LIST == sp_data_type_node->children_[1]->type_) {
2039
      ret = OB_ERR_TYPE_CANT_CONSTRAINED;
2040
      LOG_USER_ERROR(OB_ERR_TYPE_CANT_CONSTRAINED, 
2041
                    obj_access_idents.at(obj_access_idents.count()-1).access_name_.length(),
2042
                    obj_access_idents.at(obj_access_idents.count()-1).access_name_.ptr());
2043
    } else {
2044
      ret = OB_ERR_SP_UNDECLARED_TYPE;
2045
      LOG_WARN("failed to resolve composite type", K(ret), K(obj_access_idents));
2046
      LOG_USER_ERROR(OB_ERR_SP_UNDECLARED_TYPE,
2047
                    obj_access_idents.at(obj_access_idents.count()-1).access_name_.length(),
2048
                    obj_access_idents.at(obj_access_idents.count()-1).access_name_.ptr());
2049
    }
2050
  }
2051
#ifdef OB_BUILD_ORACLE_PL
2052
  //所有Type表都没有找到, 看下是否是SYS_REFCURSOR
2053
  if (OB_FAIL(ret)
2054
      && 1 == obj_access_idents.count()
2055
      && ObCharset::case_insensitive_equal(obj_access_idents.at(0).access_name_, "SYS_REFCURSOR")) {
2056
    ret = OB_SUCCESS;
2057
    ob_reset_tsi_warning_buffer();
2058
    CK (OB_NOT_NULL(current_block_->get_namespace().get_type_table()));
2059
    OX (user_type = &(current_block_->get_namespace().get_type_table()->get_sys_refcursor_type()));
2060
    OX (data_type = *user_type);
2061

2062
  } else
2063
#endif
2064
  if (OB_SUCC(ret)) {
2065
    if (!ObObjAccessIdx::is_type(access_idxs)) {
2066
      ret = OB_ERR_SP_UNDECLARED_TYPE;
2067
      LOG_WARN("type not exists", K(ret), K(access_idxs));
2068
    }
2069

2070
    OZ (current_block_->get_namespace().get_pl_data_type_by_id(
2071
      access_idxs.at(access_idxs.count() - 1).var_index_, user_type), access_idxs);
2072
    CK (OB_NOT_NULL(user_type));
2073
    if (OB_SUCC(ret)) {
2074
      if (!obj_access_idents.at(obj_access_idents.count() - 1).params_.empty()) {
2075
        ObArray<ObRawExpr*> params;
2076
        OZ (obj_access_idents.at(obj_access_idents.count() -1 ).extract_params(0, params));
2077
#ifdef OB_BUILD_ORACLE_PL
2078
        OZ (resolve_sp_subtype_precision(resolve_ctx_.session_info_, params, user_type, data_type));
2079
#endif
2080
      } else {
2081
        OX (data_type = *user_type);
2082
      }
2083
    }
2084
  }
2085

2086
  if (OB_NOT_NULL(extern_type_info)) {
2087
    if (is_object_not_exist_error(ret)
2088
      && obj_access_idents.count() >= 1) {
2089
      LOG_USER_WARN(OB_ERR_SP_UNDECLARED_TYPE,
2090
                    obj_access_idents.at(obj_access_idents.count() - 1).access_name_.length(),
2091
                    obj_access_idents.at(obj_access_idents.count() - 1).access_name_.ptr());
2092
      record_error_line(sp_data_type_node, resolve_ctx_.session_info_);
2093
      ObPL::insert_error_msg(ret);
2094
      ret = OB_SUCCESS;
2095
      OZ (resolve_extern_type_info(resolve_ctx_.schema_guard_,
2096
                                   resolve_ctx_.session_info_,
2097
                                   obj_access_idents,
2098
                                   extern_type_info));
2099
    } else if (OB_FAIL(ret) || data_type.is_obj_type()) {
2100
#ifdef OB_BUILD_ORACLE_PL
2101
    } else if (user_type->is_sys_refcursor_type()) {
2102
      OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_SYS_REFCURSOR);
2103
      OX (extern_type_info->type_name_ = ObString("SYS_REFCURSOR"));
2104
#endif
2105
    } else if (ObObjAccessIdx::is_local_type(access_idxs)) {
2106
      OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_LOCAL_VAR);
2107
      OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count()-1).var_name_);
2108
      if (access_idxs.count() > 1) {
2109
        OX (extern_type_info->type_subname_ = access_idxs.at(access_idxs.count()-2).var_name_);
2110
      }
2111
    } else if (ObObjAccessIdx::is_external_type(access_idxs)) {
2112
      OZ (resolve_extern_type_info(resolve_ctx_.schema_guard_, access_idxs, extern_type_info));
2113
    }
2114
  }
2115
  CANCLE_LOG_CHECK_MODE();
2116
  return ret;
2117
}
2118

2119
int ObPLResolver::build_pl_integer_type(ObPLIntegerType type, ObPLDataType &data_type)
2120
{
2121
  int ret = OB_SUCCESS;
2122
  ObDataType scalar_data_type;
2123
  const ObAccuracy &default_accuracy = ObAccuracy::DDL_DEFAULT_ACCURACY[ObInt32Type];
2124
  scalar_data_type.set_obj_type(ObInt32Type);
2125
  scalar_data_type.set_precision(default_accuracy.get_precision());
2126
  scalar_data_type.set_scale(0);
2127
  scalar_data_type.set_zero_fill(false);
2128
  scalar_data_type.meta_.set_scale(scalar_data_type.get_scale());
2129
  data_type.set_pl_integer_type(type, scalar_data_type);
2130
  OZ (resolve_sp_integer_constraint(data_type), data_type);
2131
  return ret;
2132
}
2133

2134
int ObPLResolver::resolve_sp_integer_type(const ParseNode *sp_data_type_node,
2135
                                          ObPLDataType &data_type)
2136
{
2137
  int ret = OB_SUCCESS;
2138
  CK (OB_NOT_NULL(sp_data_type_node));
2139
  CK (T_SP_INTEGER_TYPE == sp_data_type_node->type_);
2140
  if (OB_SUCC(ret)) {
2141
    int64_t type = sp_data_type_node->value_;
2142
    switch (type)
2143
    {
2144
#define SET_PL_INTEGER_TYPE(type)                               \
2145
  case SP_##type: {                                             \
2146
    OZ (build_pl_integer_type(PL_##type, data_type));           \
2147
    break;                                                      \
2148
  }
2149
      SET_PL_INTEGER_TYPE(PLS_INTEGER);
2150
      SET_PL_INTEGER_TYPE(BINARY_INTEGER);
2151
      SET_PL_INTEGER_TYPE(NATURAL);
2152
      SET_PL_INTEGER_TYPE(NATURALN);
2153
      SET_PL_INTEGER_TYPE(POSITIVE);
2154
      SET_PL_INTEGER_TYPE(POSITIVEN);
2155
      SET_PL_INTEGER_TYPE(SIGNTYPE);
2156
      SET_PL_INTEGER_TYPE(SIMPLE_INTEGER);
2157
#undef SET_PL_INTEGER_TYPE
2158
      default: {
2159
        ret = OB_ERR_UNEXPECTED;
2160
        LOG_WARN("unexpected pl integer type", K(type), K(ret));
2161
      }
2162
    }
2163
  }
2164
  return ret;
2165
}
2166

2167
int ObPLResolver::resolve_sp_integer_constraint(ObPLDataType &pls_type)
2168
{
2169
  int ret = OB_SUCCESS;
2170
  ObPLIntegerType type = pls_type.get_pl_integer_type();
2171
  switch (type)
2172
  {
2173
  case PL_PLS_INTEGER:
2174
  case PL_BINARY_INTEGER:
2175
  case PL_SIMPLE_INTEGER: {
2176
    pls_type.set_range(-2147483648, 2147483647);
2177
    pls_type.set_not_null(PL_SIMPLE_INTEGER == type);
2178
  }
2179
    break;
2180
  case PL_NATURAL:
2181
  case PL_NATURALN: {
2182
    pls_type.set_range(0, 2147483647);
2183
    pls_type.set_not_null(PL_NATURALN == type);
2184
  }
2185
    break;
2186
  case PL_POSITIVE:
2187
  case PL_POSITIVEN: {
2188
    pls_type.set_range(1, 2147483647);
2189
    pls_type.set_not_null(PL_POSITIVEN == type);
2190
  }
2191
    break;
2192
  case PL_SIGNTYPE: {
2193
    pls_type.set_range(-1, 1);
2194
  }
2195
    break;
2196
  default:
2197
    ret = OB_ERR_UNEXPECTED;
2198
    LOG_WARN("unexpected pl integer type", K(type), K(ret));
2199
  }
2200
  return ret;
2201
}
2202

2203
int ObPLResolver::resolve_sp_scalar_type(ObIAllocator &allocator,
2204
                                         const ParseNode *sp_data_type_node,
2205
                                         const ObString &ident_name,
2206
                                         const ObSQLSessionInfo &session_info,
2207
                                         ObPLDataType &data_type,
2208
                                         bool is_for_param_type,
2209
                                         uint64_t package_id)
2210
{
2211
  int ret = OB_SUCCESS;
2212
  CK(OB_NOT_NULL(sp_data_type_node));
2213
  if (OB_FAIL(ret)) {
2214
  } else if (T_SP_INTEGER_TYPE == sp_data_type_node->type_) {
2215
    if (OB_FAIL(resolve_sp_integer_type(sp_data_type_node, data_type))) {
2216
      LOG_WARN("fail to resolve sp integer data type", K(ret));
2217
    }
2218
  } else {
2219
    ObDataType scalar_data_type;
2220
    omt::ObTenantConfigGuard tcg(
2221
        TENANT_CONF(session_info.get_effective_tenant_id()));
2222
    bool convert_real_to_decimal =
2223
        (tcg.is_valid() && tcg->_enable_convert_real_to_decimal);
2224
    if (OB_FAIL(ObResolverUtils::resolve_data_type(*sp_data_type_node,
2225
                                      ident_name,
2226
                                      scalar_data_type,
2227
                                      is_oracle_mode(),
2228
                                      true,
2229
                                      session_info.get_session_nls_params(),
2230
                                      session_info.get_effective_tenant_id(),
2231
                                      false, // TODO
2232
                                      convert_real_to_decimal))) {
2233
      LOG_WARN("resolve data type failed", K(ret));
2234
    } else if (scalar_data_type.get_meta_type().is_string_or_lob_locator_type()
2235
            || scalar_data_type.get_meta_type().is_enum_or_set()
2236
            || scalar_data_type.get_meta_type().is_json()
2237
            || scalar_data_type.get_meta_type().is_geometry()) {
2238
      ObObjMeta tmp_meta = scalar_data_type.get_meta_type();
2239
      if (ObLongTextType == tmp_meta.get_type() && is_oracle_mode()) {
2240
        scalar_data_type.set_meta_type(tmp_meta);
2241
        scalar_data_type.set_length(-1); // was set ObLobType
2242
      }
2243
      ObCharsetType charset_type = scalar_data_type.get_charset_type();
2244
      ObCollationType collation_type = scalar_data_type.get_collation_type();
2245
      if (CHARSET_ANY == charset_type) {
2246
        if (!is_for_param_type) {
2247
          ret = OB_ERR_ANY_CS_NOT_ALLOWED;
2248
          LOG_WARN("PLS-00551: character set ANY_CS is only allowed on a subprogram parameter", K(ret));
2249
        }
2250
      } else if (CHARSET_INVALID == charset_type
2251
                 && CS_TYPE_INVALID == collation_type) {
2252
        if (lib::is_mysql_mode()) {
2253
          OZ (session_info.get_character_set_connection(charset_type));
2254
          OZ (session_info.get_collation_connection(collation_type));
2255
        } else { // oracle mode
2256
          if (OB_FAIL(ret)) {
2257
            // do nothing
2258
          } else if (OB_MIN_SYS_PL_OBJECT_ID < package_id
2259
                       && package_id < OB_MAX_SYS_PL_OBJECT_ID) {
2260
            // system package
2261
            session_info.get_collation_database(collation_type);
2262
          } else {
2263
            collation_type = scalar_data_type.get_meta_type().is_nstring() ?
2264
              session_info.get_nls_collation_nation()
2265
            : session_info.get_nls_collation();
2266
          }
2267
          if (OB_SUCC(ret)) {
2268
            charset_type = CS_TYPE_ANY == collation_type ?
2269
                           CHARSET_ANY : ObCharset::charset_type_by_coll(collation_type);
2270
          }
2271
        }
2272
      } else if (OB_FAIL(ObCharset::check_and_fill_info(charset_type, collation_type))) {
2273
        LOG_WARN("fail to fill collation info", K(charset_type), K(collation_type), K(ret));
2274
      }
2275
      if (OB_SUCC(ret)) {
2276
        scalar_data_type.set_charset_type(charset_type);
2277
        scalar_data_type.set_collation_type(collation_type);
2278
      }
2279
      if (OB_SUCC(ret) &&
2280
          (scalar_data_type.get_meta_type().is_lob()
2281
            || scalar_data_type.get_meta_type().is_lob_locator()
2282
            || scalar_data_type.get_meta_type().is_json()
2283
            || scalar_data_type.get_meta_type().is_geometry())
2284
          && CHARSET_ANY != scalar_data_type.get_charset_type()) {
2285
        ObObjType type = scalar_data_type.get_obj_type();
2286
        type = ob_is_lob_locator(type) ? ObLongTextType : type;
2287
        int32_t length = scalar_data_type.get_length();
2288
        if (OB_FAIL(ObDDLResolver::check_text_length(scalar_data_type.get_charset_type(),
2289
                                                     scalar_data_type.get_collation_type(),
2290
                                                     ident_name.ptr(),
2291
                                                     type,
2292
                                                     length,
2293
                                                     true))) {
2294
          LOG_WARN("failed to check text length", K(ret), K(scalar_data_type));
2295
        } else {
2296
          scalar_data_type.set_length(length);
2297
          if (lib::is_mysql_mode()) {
2298
            scalar_data_type.set_obj_type(type);
2299
          }
2300
        }
2301
      }
2302
      if (OB_SUCC(ret)) {
2303
        scalar_data_type.set_charset_type(charset_type);
2304
        scalar_data_type.set_collation_type(collation_type);
2305
        scalar_data_type.set_length_semantics(scalar_data_type.get_length_semantics());
2306
        scalar_data_type.meta_.set_collation_level(CS_LEVEL_IMPLICIT);
2307
      }
2308
    }
2309
    if (OB_SUCC(ret) && scalar_data_type.get_meta_type().is_enum_or_set()) {
2310
      ObArray<ObString> type_info_array;
2311
      CK(OB_LIKELY(4 == sp_data_type_node->num_child_));
2312
      CK(OB_NOT_NULL(sp_data_type_node->children_[3]));
2313
      int32_t length = 0;
2314
      if (OB_FAIL(ret)) {
2315
      } else if (OB_FAIL(ObResolverUtils::resolve_extended_type_info(*(sp_data_type_node->children_[3]),
2316
                                                                     type_info_array))) {
2317
        LOG_WARN("fail to resolve extended type info", K(ret));
2318
      } else if (OB_FAIL(ObResolverUtils::check_extended_type_info(
2319
                  allocator,
2320
                  type_info_array,
2321
                  // the resolved type info array is session connection collation.
2322
                  session_info.get_local_collation_connection(),
2323
                  ident_name,
2324
                  scalar_data_type.get_obj_type(),
2325
                  scalar_data_type.get_collation_type(),
2326
                  session_info.get_sql_mode()))) {
2327
        LOG_WARN("fail to check extended type info", K(type_info_array), K(ret));
2328
      } else if (OB_FAIL(data_type.set_type_info(type_info_array))) {
2329
        LOG_WARN("fail to set type info", K(ret));
2330
      } else if (OB_FAIL(ObDDLResolver::calc_enum_or_set_data_length(type_info_array,
2331
                                                  scalar_data_type.get_collation_type(),
2332
                                                  scalar_data_type.get_obj_type(), length))) {
2333
        LOG_WARN("failed to calc enum or set data length", K(ret));
2334
      } else {
2335
        scalar_data_type.set_length(length);
2336
      }
2337
    }
2338
    if (OB_SUCC(ret)) {
2339
      // resolve_data_type会将scale设置在accuracy上,这里将meta_的scale设置下
2340
      if (scalar_data_type.get_meta_type().is_bit()) { // 对于bit类型, scale存储的是长度信息
2341
        scalar_data_type.meta_.set_scale(scalar_data_type.get_precision());
2342
      } else {
2343
        scalar_data_type.meta_.set_scale(scalar_data_type.get_scale());
2344
        if (is_lob_storage(scalar_data_type.get_meta_type().get_type())) {
2345
          scalar_data_type.meta_.set_has_lob_header();
2346
        }
2347
      }
2348
      data_type.set_data_type(scalar_data_type);
2349
    }
2350
    if (OB_SUCC(ret)
2351
        && ObRawType == scalar_data_type.get_meta_type().get_type()
2352
        && lib::is_oracle_mode()) {
2353
      const int64_t data_len = scalar_data_type.accuracy_.get_length();
2354
      if (data_len < 0 || data_len > OB_MAX_ORACLE_RAW_PL_VAR_LENGTH) {
2355
        ret = OB_ERR_TOO_LONG_COLUMN_LENGTH;
2356
        LOG_WARN("raw data length is invalid",
2357
                 K(ret), K(OB_MAX_ORACLE_RAW_PL_VAR_LENGTH), "real_data_length", data_len);
2358
        LOG_USER_ERROR(OB_ERR_TOO_LONG_COLUMN_LENGTH,
2359
                       "RAW TYPE", static_cast<int>(OB_MAX_ORACLE_RAW_PL_VAR_LENGTH));
2360
      } else if (0 == data_len) {
2361
        ret = OB_ERR_ZERO_LEN_COL;
2362
        LOG_WARN("raw data length cannot be zero on oracle mode", K(ret), K(data_len));
2363
      }
2364
    }
2365
  }
2366
  LOG_DEBUG("resolve sp scalar type result", K(ret), K(data_type), K(lbt()));
2367
  return ret;
2368
}
2369

2370
int ObPLResolver::get_view_select_stmt(
2371
  const ObPLResolveCtx &ctx, const ObTableSchema* view_schema, ObSelectStmt *&select_stmt)
2372
{
2373
  int ret = OB_SUCCESS;
2374
  ObStmtFactory stmt_factory(ctx.allocator_);
2375
  ObRawExprFactory expr_factory(ctx.allocator_);
2376
  const ObDatabaseSchema *db_schema = NULL;
2377
  ObSqlString select_sql;
2378
  ParseResult parse_result;
2379
  ObParser parser(ctx.allocator_, ctx.session_info_.get_sql_mode());
2380
  ObSchemaChecker schema_checker;
2381
  ObResolverParams resolver_ctx;
2382
  ParseNode *select_stmt_node = NULL;
2383

2384
  OZ (ctx.schema_guard_.get_database_schema(view_schema->get_tenant_id(),
2385
      view_schema->get_database_id(), db_schema));
2386
  CK (OB_NOT_NULL(db_schema));
2387
  OZ (select_sql.append_fmt(
2388
    "select * from \"%.*s\".\"%.*s\"",
2389
    db_schema->get_database_name_str().length(), db_schema->get_database_name_str().ptr(),
2390
    view_schema->get_table_name_str().length(), view_schema->get_table_name_str().ptr()));
2391
  OZ (parser.parse(select_sql.string(), parse_result));
2392
  OZ (schema_checker.init(ctx.schema_guard_, ctx.session_info_.get_sessid()));
2393

2394
  OX (resolver_ctx.allocator_ = &(ctx.allocator_));
2395
  OX (resolver_ctx.schema_checker_ = &schema_checker);
2396
  OX (resolver_ctx.session_info_ = &(ctx.session_info_));
2397
  OX (resolver_ctx.expr_factory_ = &expr_factory);
2398
  OX (resolver_ctx.stmt_factory_ = &stmt_factory);
2399
  CK (OB_NOT_NULL(resolver_ctx.query_ctx_ = stmt_factory.get_query_ctx()));
2400
  OX (resolver_ctx.query_ctx_->question_marks_count_
2401
        = static_cast<int64_t>(parse_result.question_mark_ctx_.count_));
2402

2403
  CK (OB_NOT_NULL(select_stmt_node = parse_result.result_tree_->children_[0]));
2404
  CK (T_SELECT == select_stmt_node->type_);
2405

2406
  ObSelectResolver select_resolver(resolver_ctx);
2407
  OZ (SMART_CALL(select_resolver.resolve(*select_stmt_node)));
2408
  CK (OB_NOT_NULL(select_stmt = static_cast<ObSelectStmt*>(select_resolver.get_basic_stmt())));
2409

2410
  // CK (OB_LIKELY(1 == select_stmt->get_table_size()));
2411
  // CK (OB_NOT_NULL(view_item = select_stmt->get_table_item(0)));
2412
  // CK (OB_NOT_NULL(select_stmt = static_cast<ObSelectStmt*>(view_item->ref_query_)));
2413
  return ret;
2414
}
2415

2416
int ObPLResolver::fill_record_type(
2417
  ObSchemaGetterGuard &schema_guard, ObIAllocator &allocator, ObSelectStmt *select_stmt, ObRecordType *&record_type)
2418
{
2419
  int ret = OB_SUCCESS;
2420
  const SelectItem *select_item = NULL;
2421
  const ObRawExpr *expr = NULL;
2422
  CK (OB_NOT_NULL(select_stmt));
2423
  OZ (record_type->record_members_init(&allocator, select_stmt->get_select_item_size()));
2424
  for (int64_t i = 0; OB_SUCC(ret) && i < select_stmt->get_select_item_size(); ++i) {
2425
    ObString copy_name;
2426
    ObDataType data_type;
2427
    ObPLDataType pl_type;
2428
    CK (OB_NOT_NULL(select_item = &(select_stmt->get_select_item(i))));
2429
    CK (OB_NOT_NULL(expr = select_item->expr_));
2430
    if (OB_FAIL(ret)) {
2431
    } else if (expr->get_result_type().is_ext() || expr->get_result_type().is_user_defined_sql_type()) {
2432
      const ObUDTTypeInfo *udt_info = NULL;
2433
      const ObUserDefinedType *user_type = NULL;
2434
      ObArenaAllocator allocator;
2435
      uint64_t udt_id = expr->get_result_type().get_expr_udt_id();
2436
      uint64_t tenant_id = get_tenant_id_by_object_id(udt_id);
2437
      OZ (schema_guard.get_udt_info(tenant_id, udt_id, udt_info));
2438
      CK (OB_NOT_NULL(udt_info));
2439
      OZ (udt_info->transform_to_pl_type(allocator, user_type));
2440
      OX (pl_type = *user_type);
2441
    } else {
2442
      OX (data_type.set_meta_type(expr->get_result_type()));
2443
      OX (data_type.set_accuracy(expr->get_result_type().get_accuracy()));
2444
      OX (pl_type.set_data_type(data_type));
2445
    }
2446
    OZ (ob_write_string(allocator, select_item->alias_name_, copy_name));
2447
    OZ (record_type->add_record_member(copy_name, pl_type));
2448
  }
2449
  return ret;
2450
}
2451

2452
int ObPLResolver::build_record_type_by_view_schema(const ObPLResolveCtx &ctx,
2453
                                                   const ObTableSchema* view_schema,
2454
                                                   ObRecordType *&record_type)
2455
{
2456
  int ret = OB_SUCCESS;
2457
  ObSelectStmt *select_stmt = NULL;
2458
  ObSelectStmt *real_stmt = NULL;
2459
  ObArenaAllocator alloc;
2460
  ObStmtFactory stmt_factory(alloc);
2461
  ObRawExprFactory expr_factory(alloc);
2462
  const ObDatabaseSchema *db_schema = NULL;
2463
  ObSqlString select_sql;
2464
  ParseResult parse_result;
2465
  ObParser parser(alloc, ctx.session_info_.get_sql_mode(),
2466
                  ctx.session_info_.get_charsets4parser());
2467
  ObSchemaChecker schema_checker;
2468
  ObResolverParams resolver_ctx;
2469
  ParseNode *select_stmt_node = NULL;
2470

2471
  OZ (ctx.schema_guard_.get_database_schema(view_schema->get_tenant_id(),
2472
      view_schema->get_database_id(), db_schema));
2473
  CK (OB_NOT_NULL(db_schema));
2474
  OZ (select_sql.append_fmt(
2475
    "select * from \"%.*s\".\"%.*s\"",
2476
    db_schema->get_database_name_str().length(), db_schema->get_database_name_str().ptr(),
2477
    view_schema->get_table_name_str().length(), view_schema->get_table_name_str().ptr()));
2478
  OZ (parser.parse(select_sql.string(), parse_result));
2479
  OZ (schema_checker.init(ctx.schema_guard_, ctx.session_info_.get_sessid()));
2480

2481
  OX (resolver_ctx.allocator_ = &(alloc));
2482
  OX (resolver_ctx.schema_checker_ = &schema_checker);
2483
  OX (resolver_ctx.session_info_ = &(ctx.session_info_));
2484
  OX (resolver_ctx.expr_factory_ = &expr_factory);
2485
  OX (resolver_ctx.stmt_factory_ = &stmt_factory);
2486
  OX (resolver_ctx.sql_proxy_ = &(ctx.sql_proxy_));
2487
  CK (OB_NOT_NULL(resolver_ctx.query_ctx_ = stmt_factory.get_query_ctx()));
2488
  OX (resolver_ctx.query_ctx_->question_marks_count_
2489
        = static_cast<int64_t>(parse_result.question_mark_ctx_.count_));
2490

2491
  CK (OB_NOT_NULL(select_stmt_node = parse_result.result_tree_->children_[0]));
2492
  CK (T_SELECT == select_stmt_node->type_);
2493

2494
  ObSelectResolver select_resolver(resolver_ctx);
2495
  OZ (SMART_CALL(select_resolver.resolve(*select_stmt_node)));
2496
  CK (OB_NOT_NULL(select_stmt = static_cast<ObSelectStmt*>(select_resolver.get_basic_stmt())));
2497
  // OZ (get_view_select_stmt(resolve_ctx, view_schema, select_stmt));
2498
  CK (OB_NOT_NULL(real_stmt = select_stmt->get_real_stmt()));
2499
  CK (OB_NOT_NULL(record_type));
2500
  OZ (fill_record_type(ctx.schema_guard_, ctx.allocator_, real_stmt, record_type));
2501
  return ret;
2502
}
2503

2504
int ObPLResolver::build_record_type_by_table_schema(ObSchemaGetterGuard &schema_guard,
2505
                                                    common::ObIAllocator &allocator,
2506
                                                    const ObTableSchema* table_schema,
2507
                                                    ObRecordType *&record_type,
2508
                                                    bool with_rowid)
2509
{
2510
  int ret = OB_SUCCESS;
2511
  CK (OB_NOT_NULL(table_schema));
2512
  OZ (record_type->record_members_init(&allocator, table_schema->get_column_count() + 1));
2513
  if (OB_SUCC(ret)) {
2514
    ObTableSchema::const_column_iterator cs_iter = table_schema->column_begin();
2515
    ObTableSchema::const_column_iterator cs_iter_end = table_schema->column_end();
2516
    for (; OB_SUCC(ret) && cs_iter != cs_iter_end; cs_iter++) {
2517
      const ObColumnSchemaV2 &column_schema = **cs_iter;
2518
      if (!column_schema.is_hidden() && !(column_schema.is_invisible_column() && !with_rowid)) {
2519
        ObPLDataType pl_type;
2520
        if (column_schema.get_meta_type().is_user_defined_sql_type()) {
2521
          const ObUDTTypeInfo *udt_info = NULL;
2522
          const ObUserDefinedType *user_type = NULL;
2523
          ObArenaAllocator allocator;
2524
          uint64_t tenant_id = get_tenant_id_by_object_id(column_schema.get_sub_data_type());
2525
          OZ (schema_guard.get_udt_info(tenant_id, column_schema.get_sub_data_type(), udt_info));
2526
          CK (OB_NOT_NULL(udt_info));
2527
          OZ (udt_info->transform_to_pl_type(allocator, user_type));
2528
          CK (OB_NOT_NULL(user_type));
2529
          OX (pl_type = *user_type);
2530
        } else {
2531
          ObDataType data_type;
2532
          data_type.set_meta_type(column_schema.get_meta_type());
2533
          data_type.set_accuracy(column_schema.get_accuracy());
2534
          if (data_type.get_meta_type().is_bit()) { // 对于bit类型, scale存储的是长度信息
2535
            data_type.meta_.set_scale(data_type.get_precision());
2536
          } else {
2537
            data_type.meta_.set_scale(data_type.get_scale());
2538
          }
2539
          if (column_schema.is_enum_or_set()) {
2540
            OZ (pl_type.set_type_info(column_schema.get_extended_type_info()));
2541
          }
2542
          OX (pl_type.set_data_type(data_type));
2543
        }
2544
        if (OB_SUCC(ret)) {
2545
          char *name_buf = NULL;
2546
          ObString column_name = column_schema.get_column_name_str();
2547
          if (OB_ISNULL(name_buf =
2548
              static_cast<char*>(allocator.alloc(column_name.length() + 1)))) {
2549
            ret = OB_ALLOCATE_MEMORY_FAILED;
2550
            LOG_WARN("failed to alloc column name buf", K(ret), K(column_name));
2551
          } else {
2552
            MEMCPY(name_buf, column_name.ptr(), column_name.length());
2553
            ObString deep_copy_name(column_name.length(), name_buf);
2554
            OZ (record_type->add_record_member(deep_copy_name, pl_type));
2555
          }
2556
        }
2557
      }
2558
    }
2559
  }
2560
  if (OB_SUCC(ret) && with_rowid && lib::is_oracle_mode()) {
2561
    ObDataType data_type;
2562
    ObPLDataType pl_type;
2563
    data_type.set_obj_type(ObURowIDType);
2564
    data_type.set_length(OB_MAX_USER_ROW_KEY_LENGTH);
2565
    data_type.set_precision(-1);
2566
    data_type.set_collation_type(CS_TYPE_BINARY);
2567
    pl_type.set_data_type(data_type);
2568
    char *name_buf = NULL;
2569
    ObString column_name(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME);
2570
    if (OB_ISNULL(name_buf = static_cast<char*>(allocator.
2571
        alloc(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME_LENGTH + 1)))) {
2572
      ret = OB_ALLOCATE_MEMORY_FAILED;
2573
      LOG_WARN("failed to alloc column name buf", K(ret), K(column_name));
2574
    } else {
2575
      MEMCPY(name_buf, column_name.ptr(), column_name.length());
2576
      ObString deep_copy_name(column_name.length(), name_buf);
2577
      OZ (record_type->add_record_member(deep_copy_name, pl_type));
2578
    }
2579
  }
2580
  return ret;
2581
}
2582

2583
int ObPLResolver::build_record_type_by_schema(
2584
  const ObPLResolveCtx &resolve_ctx, const ObTableSchema* table_schema,
2585
  ObRecordType *&record_type, bool with_rowid)
2586
{
2587
  int ret = OB_SUCCESS;
2588
  CK (OB_NOT_NULL(table_schema));
2589
  OX (record_type = NULL);
2590
  if (OB_SUCC(ret)) {
2591
    if (OB_ISNULL(record_type =
2592
        static_cast<ObRecordType*>(resolve_ctx.allocator_.alloc(sizeof(ObRecordType))))) {
2593
      ret = OB_ALLOCATE_MEMORY_FAILED;
2594
      LOG_WARN("failed to alloc memory for ObRecordtype!", K(ret));
2595
    } else {
2596
      ObSqlString type_fmt_name;
2597
      ObString type_name;
2598
      OZ (type_fmt_name.append_fmt("%s%%ROWTYPE", table_schema->get_table_name()));
2599
      OZ (ob_write_string(resolve_ctx.allocator_, type_fmt_name.string(), type_name));
2600
      OX (record_type = new(record_type)ObRecordType())
2601
      OX (record_type->set_name(type_name));
2602
      OX (record_type->set_user_type_id(table_schema->get_table_id()));
2603
      OX (record_type->set_type_from(PL_TYPE_ATTR_ROWTYPE));
2604
    }
2605
  }
2606
  if (OB_SUCC(ret)) {
2607
    if (table_schema->is_view_table() && !table_schema->is_materialized_view()) {
2608
      OZ (build_record_type_by_view_schema(
2609
        resolve_ctx, table_schema, record_type));
2610
    } else {
2611
      OZ (build_record_type_by_table_schema(
2612
        resolve_ctx.schema_guard_, resolve_ctx.allocator_, table_schema, record_type, with_rowid));
2613
    }
2614
  }
2615
  return ret;
2616
}
2617

2618
int ObPLResolver::resolve_extern_type_info(ObSchemaGetterGuard &schema_guard,
2619
                                           const ObSQLSessionInfo &session_info,
2620
                                           const ObIArray<ObObjAccessIdent> &access_idents,
2621
                                           ObPLExternTypeInfo *extern_type_info)
2622
{
2623
  int ret = OB_SUCCESS;
2624
  SET_LOG_CHECK_MODE();
2625
  CK (OB_NOT_NULL(extern_type_info));
2626
  CK (access_idents.count() > 0 && access_idents.count() <= 3);
2627
  if (OB_FAIL(ret)) {
2628
  } else if (3 == access_idents.count()) { //db.pkg.type
2629
    OZ (schema_guard.get_database_id(session_info.get_effective_tenant_id(),
2630
      access_idents.at(0).access_name_, extern_type_info->type_owner_));
2631
    OX (extern_type_info->type_subname_ = access_idents.at(1).access_name_);
2632
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_PKG);
2633
  } else if (2 == access_idents.count()) { // pkg.type or db.type
2634
    OZ (schema_guard.get_database_id(session_info.get_effective_tenant_id(),
2635
      access_idents.at(0).access_name_, extern_type_info->type_owner_));
2636
    if (OB_ERR_BAD_DATABASE == ret || OB_INVALID_ID == extern_type_info->type_owner_) {
2637
      ret = OB_SUCCESS;
2638
      OX (extern_type_info->type_subname_ = access_idents.at(0).access_name_);
2639
      OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_PKG);
2640
    } else {
2641
      OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_UDT);
2642
    }
2643
  } else {
2644
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_UDT);
2645
  }
2646
  if (OB_SUCC(ret) && OB_INVALID_ID == extern_type_info->type_owner_) {
2647
    OZ (session_info.get_database_id(extern_type_info->type_owner_));
2648
  }
2649
  OX (extern_type_info->type_name_ = access_idents.at(access_idents.count() - 1).access_name_);
2650
  CANCLE_LOG_CHECK_MODE();
2651
  return ret;
2652
}
2653

2654
int ObPLResolver::resolve_extern_type_info(bool is_row_type,
2655
                                           ObSchemaGetterGuard &schema_guard,
2656
                                           const ObSQLSessionInfo &session_info,
2657
                                           const ObIArray<ObObjAccessIdent> &access_idents,
2658
                                           ObPLExternTypeInfo *extern_type_info)
2659
{
2660
  int ret = OB_SUCCESS;
2661
  CK (OB_NOT_NULL(extern_type_info));
2662
  if (OB_FAIL(ret)) {
2663
  } else if (is_row_type) { // must be table%rowtype or dbname.table%rowtype
2664
    CK (access_idents.count() <= 2 && access_idents.count() >= 1);
2665
    if (OB_FAIL(ret)) {
2666
    } else if (2 == access_idents.count()) {
2667
      OZ (schema_guard.get_database_id(session_info.get_effective_tenant_id(),
2668
        access_idents.at(0).access_name_, extern_type_info->type_owner_));
2669
    } else {
2670
      OZ (session_info.get_database_id(extern_type_info->type_owner_));
2671
    }
2672
    OX (extern_type_info->type_name_ = access_idents.at(access_idents.count() - 1).access_name_);
2673
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_TAB);
2674
  } else { // dbname.table.col%type or table.col%type, dbname.pack.var%type, pack.var%type
2675
    CK (access_idents.count() <= 3 && access_idents.count() >= 2);
2676
    if (OB_FAIL(ret)) {
2677
    } else if (3 == access_idents.count()) {
2678
      OZ (schema_guard.get_database_id(session_info.get_effective_tenant_id(),
2679
        access_idents.at(0).access_name_, extern_type_info->type_owner_));
2680
    } else {
2681
      OZ (session_info.get_database_id(extern_type_info->type_owner_));
2682
    }
2683
    OX (extern_type_info->type_name_ = access_idents.at(access_idents.count() - 1).access_name_);
2684
    OX (extern_type_info->type_subname_ = access_idents.at(access_idents.count() - 2).access_name_);
2685
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_PKGVAR_OR_TABCOL);
2686
  }
2687
  return ret;
2688
}
2689

2690
int ObPLResolver::resolve_extern_type_info(ObSchemaGetterGuard &guard,
2691
                                           const ObIArray<ObObjAccessIdx> &access_idxs,
2692
                                           ObPLExternTypeInfo *extern_type_info)
2693
{
2694
  int ret = OB_SUCCESS;
2695
  CK (ObObjAccessIdx::is_table_column(access_idxs)
2696
      || ObObjAccessIdx::is_package_variable(access_idxs)
2697
      || ObObjAccessIdx::is_table(access_idxs)
2698
      || ObObjAccessIdx::is_local_variable(access_idxs)
2699
      || ObObjAccessIdx::is_external_type(access_idxs));
2700
  if (OB_ISNULL(extern_type_info)) {
2701
    // do nothing ...
2702
  } else if (ObObjAccessIdx::is_table_column(access_idxs)) {
2703
    CK (2 == access_idxs.count() || 3 == access_idxs.count());
2704
    OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count() - 1).var_name_);
2705
    OX (extern_type_info->type_subname_ = access_idxs.at(access_idxs.count() - 2).var_name_);
2706
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_TAB_COL);
2707
    if (OB_FAIL(ret)) {
2708
    } else if (3 == access_idxs.count()) {
2709
      extern_type_info->type_owner_ = access_idxs.at(0).var_index_;
2710
    } else {
2711
      const ObTableSchema *table = NULL;
2712
      const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
2713
      OZ (guard.get_table_schema(tenant_id, access_idxs.at(0).var_index_, table));
2714
      CK (OB_NOT_NULL(table));
2715
      OX (extern_type_info->type_owner_ = table->get_database_id());
2716
    }
2717
    OZ (fill_schema_obj_version(guard,
2718
                                ObParamExternType::SP_EXTERN_TAB_COL,
2719
                                access_idxs.at(access_idxs.count() - 2).var_index_,
2720
                                *extern_type_info));
2721
  } else if (ObObjAccessIdx::is_package_variable(access_idxs)) {
2722
    ObObjAccessIdx::AccessType type = ObObjAccessIdx::IS_INVALID;
2723
    uint64_t package_id = OB_INVALID_ID;
2724
    CK (access_idxs.count() <= 3);
2725
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_PKG_VAR);
2726
    OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count() - 1).var_name_);
2727
    OX (access_idxs.count() > 1 ?
2728
      extern_type_info->type_subname_ = access_idxs.at(access_idxs.count() - 2).var_name_
2729
      // 这里处理特殊情况，当前ns为package，变量也是pacakge local var的情况下，ObParamExternType被强制修改为
2730
      // SP_EXTERN_PKG_VAR(ns.resolve_symbol)，但是access_idxs只有一个，因为没有使用.这种feild access，
2731
      // 因此也需要赋值pacakge name, type_owner_则会在函数底部赋值为当前的database_id.
2732
      : extern_type_info->type_subname_ = current_block_->get_namespace().get_package_name());
2733
    if (OB_FAIL(ret)) {
2734
    } else if (3 == access_idxs.count()) {
2735
      if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(1).var_index_)) {
2736
        extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2737
      } else {
2738
        extern_type_info->type_owner_ = access_idxs.at(0).var_index_;
2739
      }
2740
      OX (package_id = access_idxs.at(1).var_index_);
2741
      OX (type = access_idxs.at(1).access_type_);
2742
    } else if (2 == access_idxs.count()) {
2743
      if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(0).var_index_)) { // 系统包中的Var
2744
        extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2745
      } else {
2746
        OZ(resolve_ctx_.session_info_.get_database_id(extern_type_info->type_owner_));
2747
      }
2748
      OX (package_id = access_idxs.at(0).var_index_);
2749
      OX (type = access_idxs.at(0).access_type_);
2750
    } else {
2751
      OZ(resolve_ctx_.session_info_.get_database_id(extern_type_info->type_owner_));
2752
      OX (package_id = current_block_->get_namespace().get_package_id());
2753
      OX (type = ObObjAccessIdx::IS_PKG_NS);
2754
    }
2755
    if (ObObjAccessIdx::IS_LABEL_NS == type) {
2756
      // do nothing
2757
    } else {
2758
      OZ (fill_schema_obj_version(guard,
2759
                                  ObParamExternType::SP_EXTERN_PKG_VAR,
2760
                                  package_id,
2761
                                  *extern_type_info));
2762
    }
2763
  } else if (ObObjAccessIdx::is_table(access_idxs)) {
2764
    CK (1 == access_idxs.count() || 2 == access_idxs.count());
2765
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_TAB);
2766
    OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count() - 1).var_name_);
2767
    if (OB_FAIL(ret)) {
2768
    } else if (2 == access_idxs.count()) {
2769
      extern_type_info->type_owner_ = access_idxs.at(0).var_index_;
2770
    } else {
2771
      const ObTableSchema *table = NULL;
2772
      const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
2773
      OZ (guard.get_table_schema(tenant_id, access_idxs.at(0).var_index_, table));
2774
      CK (OB_NOT_NULL(table));
2775
      OX (extern_type_info->type_owner_ = table->get_database_id());
2776
    }
2777
    OZ (fill_schema_obj_version(guard,
2778
                                ObParamExternType::SP_EXTERN_TAB,
2779
                                access_idxs.at(access_idxs.count() - 1).var_index_,
2780
                                *extern_type_info));
2781
  } else if (ObObjAccessIdx::is_local_variable(access_idxs)) {
2782
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_LOCAL_VAR);
2783
  } else if (ObObjAccessIdx::is_pkg_type(access_idxs)) {
2784
    CK (access_idxs.count() <= 3);
2785
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_PKG);
2786
    OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count() - 1).var_name_);
2787
    if (OB_FAIL(ret)) {
2788
    } else if (access_idxs.count() > 1) { // db.pkg.type or pkg.type
2789
      extern_type_info->type_subname_ = access_idxs.at(access_idxs.count() - 2).var_name_;
2790
      if (3 == access_idxs.count()) {
2791
        if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(1).var_index_)) {
2792
          extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2793
        } else {
2794
          extern_type_info->type_owner_ = access_idxs.at(0).var_index_;
2795
        }
2796
      } else if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(0).var_index_)) {
2797
        extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2798
      }
2799
    } else if (extract_package_id(access_idxs.at(0).var_index_)
2800
               != current_block_->get_namespace().get_package_id()) {
2801
      // type (current package type or standard type)
2802
      const ObPackageInfo *package_info = NULL;
2803
      const uint64_t package_id = extract_package_id(access_idxs.at(0).var_index_);
2804
      const uint64_t tenant_id = get_tenant_id_by_object_id(package_id);
2805
      CK (1 == access_idxs.count());
2806
      OZ (guard.get_package_info(tenant_id, package_id, package_info));
2807
      CK (OB_NOT_NULL(package_info));
2808
      OX (extern_type_info->type_subname_ = package_info->get_package_name());
2809
      OX (extern_type_info->type_owner_ = package_info->get_database_id());
2810
    } else {
2811
      extern_type_info->type_subname_ = current_block_->get_namespace().get_package_name();
2812
    }
2813
    OZ (fill_schema_obj_version(guard,
2814
                          ObParamExternType::SP_EXTERN_PKG,
2815
                          extract_package_id(access_idxs.at(access_idxs.count() - 1).var_index_),
2816
                          *extern_type_info));
2817
  } else if (ObObjAccessIdx::is_udt_type(access_idxs)) {
2818
  CK (access_idxs.count() <= 2);
2819
    OX (extern_type_info->flag_ = ObParamExternType::SP_EXTERN_UDT);
2820
    OX (extern_type_info->type_name_ = access_idxs.at(access_idxs.count() - 1).var_name_);
2821
    if (OB_FAIL(ret)) {
2822
    } else if (2 == access_idxs.count()) {
2823
      if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(1).var_index_)) {
2824
        extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2825
      } else {
2826
        extern_type_info->type_owner_ = access_idxs.at(0).var_index_;
2827
      }
2828
    } else if (OB_SYS_TENANT_ID == get_tenant_id_by_object_id(access_idxs.at(0).var_index_)) {
2829
      extern_type_info->type_owner_ = OB_SYS_DATABASE_ID;
2830
    }
2831
    OZ (fill_schema_obj_version(guard,
2832
                                ObParamExternType::SP_EXTERN_UDT,
2833
                                access_idxs.at(access_idxs.count() - 1).var_index_,
2834
                                *extern_type_info));
2835
  }
2836
  if (OB_SUCC(ret)
2837
      && OB_NOT_NULL(extern_type_info)
2838
      && OB_INVALID_ID == extern_type_info->type_owner_) {
2839
    OZ (resolve_ctx_.session_info_.get_database_id(extern_type_info->type_owner_));
2840
  }
2841
  return ret;
2842
}
2843

2844
int ObPLResolver::fill_schema_obj_version(ObSchemaGetterGuard &guard,
2845
                                          ObParamExternType type,
2846
                                          uint64_t obj_id,
2847
                                          ObPLExternTypeInfo &extern_type_info)
2848
{
2849
  int ret = OB_SUCCESS;
2850

2851
#define FILL(class, func, type) \
2852
do { \
2853
  const class *info = NULL; \
2854
  OZ (guard.func(tenant_id, obj_id, info)); \
2855
  CK (OB_NOT_NULL(info)); \
2856
  OX (extern_type_info.obj_version_.object_id_ = obj_id); \
2857
  OX (extern_type_info.obj_version_.version_ = info->get_schema_version()); \
2858
  OX (extern_type_info.obj_version_.object_type_ = type); \
2859
} while (0)
2860

2861
  switch (type) {
2862
    case ObParamExternType::SP_EXTERN_TAB:
2863
    case ObParamExternType::SP_EXTERN_TAB_COL: {
2864
      const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
2865
      FILL(ObTableSchema, get_table_schema, DEPENDENCY_TABLE);
2866
    } break;
2867
    case ObParamExternType::SP_EXTERN_PKG:
2868
    case ObParamExternType::SP_EXTERN_PKG_VAR: {
2869
      const uint64_t tenant_id = get_tenant_id_by_object_id(obj_id);
2870
      CK (OB_NOT_NULL(current_block_));
2871
      if (OB_SUCC(ret)) {
2872
        if (OB_INVALID_ID == obj_id
2873
              || obj_id == current_block_->get_namespace().get_package_id()) {
2874
          // same package, do nothing ...
2875
        } else {
2876
          FILL(ObPackageInfo, get_package_info, DEPENDENCY_PACKAGE);
2877
        }
2878
      }
2879
    } break;
2880
    case ObParamExternType::SP_EXTERN_UDT: {
2881
      const uint64_t tenant_id = get_tenant_id_by_object_id(obj_id);
2882
      FILL(ObUDTTypeInfo, get_udt_info, DEPENDENCY_TYPE);
2883
    } break;
2884
    default: {
2885
      // do nothing ...
2886
    }
2887
  }
2888
#undef FILL
2889
  return ret;
2890
}
2891

2892
bool ObPLResolver::is_data_type_name(const ObString &ident_name)
2893
{
2894
  bool is_same = false;
2895
  if (0 == ident_name.case_compare("NUMERIC") ||
2896
      0 == ident_name.case_compare("NUMBER") ||
2897
      0 == ident_name.case_compare("FLOAT") ||
2898
      0 == ident_name.case_compare("REAL") ||
2899
      0 == ident_name.case_compare("TIMESTAMP") ||
2900
      0 == ident_name.case_compare("SMALLINT") ||
2901
      0 == ident_name.case_compare("INTEGER") ||
2902
      0 == ident_name.case_compare("DECIMAL") ||
2903
      0 == ident_name.case_compare("PLS_INTEGER") ||
2904
      0 == ident_name.case_compare("BINARY_INTEGER") ||
2905
      0 == ident_name.case_compare("NATURAL") ||
2906
      0 == ident_name.case_compare("NATURALN") ||
2907
      0 == ident_name.case_compare("POSITIVE") ||
2908
      0 == ident_name.case_compare("POSITIVEN") ||
2909
      0 == ident_name.case_compare("SIGNTYPE") ||
2910
      0 == ident_name.case_compare("SIMPLE_INTEGER") ||
2911
      0 == ident_name.case_compare("BOOLEAN") ||
2912
      0 == ident_name.case_compare("BINARY_DOUBLE") ||
2913
      0 == ident_name.case_compare("BINARY_FLOAT") ||
2914
      0 == ident_name.case_compare("SIMPLE_DOUBLE") ||
2915
      0 == ident_name.case_compare("SIMPLE_FLOAT") ||
2916
      0 == ident_name.case_compare("DATE") ||
2917
      0 == ident_name.case_compare("RAW") ||
2918
      0 == ident_name.case_compare("NCHAR") ||
2919
      0 == ident_name.case_compare("VARCHAR") ||
2920
      0 == ident_name.case_compare("VARCHAR2") ||
2921
      0 == ident_name.case_compare("NVARCHAR2") ||
2922
      0 == ident_name.case_compare("CLOB") ||
2923
      0 == ident_name.case_compare("UROWID") ||
2924
      0 == ident_name.case_compare("ROWID")) {
2925
    is_same = true;
2926
  }
2927
  return is_same;
2928
}
2929

2930
int ObPLResolver::resolve_sp_row_type(const ParseNode *sp_data_type_node,
2931
                                      ObPLCompileUnitAST &func,
2932
                                      ObPLDataType &pl_type,
2933
                                      ObPLExternTypeInfo *extern_type_info,
2934
                                      bool with_rowid)
2935
{
2936
  int ret = OB_SUCCESS;
2937

2938
  ObArray<ObObjAccessIdent> obj_access_idents;
2939
  SET_LOG_CHECK_MODE();
2940
  CK (OB_NOT_NULL(sp_data_type_node),
2941
      OB_LIKELY(T_SP_TYPE == sp_data_type_node->type_
2942
                || T_SP_ROWTYPE == sp_data_type_node->type_),
2943
      OB_LIKELY(1 == sp_data_type_node->num_child_),
2944
      OB_NOT_NULL(sp_data_type_node->children_[0]),
2945
      OB_LIKELY(T_SP_OBJ_ACCESS_REF == sp_data_type_node->children_[0]->type_));
2946

2947
  OZ (resolve_obj_access_idents(*(sp_data_type_node->children_[0]), obj_access_idents, func));
2948
  CK (obj_access_idents.count() > 0);
2949
  OX (obj_access_idents.at(obj_access_idents.count() - 1).has_brackets_ = false);
2950
  if (OB_SUCC(ret)) {
2951
    ObPLSwitchDatabaseGuard switch_db_guard(resolve_ctx_.session_info_,
2952
                                            resolve_ctx_.schema_guard_,
2953
                                            func,
2954
                                            ret,
2955
                                            with_rowid);
2956
    ObArray<ObObjAccessIdx> access_idxs;
2957
    for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_idents.count(); ++i) {
2958
      OZ (resolve_access_ident(obj_access_idents.at(i),
2959
                               current_block_->get_namespace(),
2960
                               expr_factory_,
2961
                               &resolve_ctx_.session_info_,
2962
                               access_idxs,
2963
                               func,
2964
                               false,
2965
                               true));
2966
      if (OB_ERR_SP_UNDECLARED_VAR == ret && is_data_type_name(obj_access_idents.at(i).access_name_)) {
2967
        ret  = OB_ERR_TYPE_DECL_ILLEGAL;
2968
        LOG_USER_ERROR(OB_ERR_TYPE_DECL_ILLEGAL, obj_access_idents.at(i).access_name_.length(),
2969
                                                 obj_access_idents.at(i).access_name_.ptr());
2970
      }
2971
    }
2972
    // 创建package的时候可能依赖的外部类型还没有创建, 记录下外部类型的name信息, 执行的时候重新解析
2973
    if (OB_NOT_NULL(extern_type_info)
2974
        && is_object_not_exist_error(ret)
2975
        && obj_access_idents.count() >= 1) {
2976
      LOG_USER_WARN(OB_ERR_SP_UNDECLARED_TYPE,
2977
                    obj_access_idents.at(obj_access_idents.count() - 1).access_name_.length(),
2978
                    obj_access_idents.at(obj_access_idents.count() - 1).access_name_.ptr());
2979
      record_error_line(sp_data_type_node, resolve_ctx_.session_info_);
2980
      ObPL::insert_error_msg(ret);
2981
      ret = OB_SUCCESS;
2982
      CK (T_SP_ROWTYPE == sp_data_type_node->type_ || T_SP_TYPE == sp_data_type_node->type_);
2983
      OZ (resolve_extern_type_info(T_SP_ROWTYPE == sp_data_type_node->type_,
2984
                                   resolve_ctx_.schema_guard_,
2985
                                   resolve_ctx_.session_info_,
2986
                                   obj_access_idents,
2987
                                   extern_type_info));
2988
    } else if (OB_FAIL(ret)) {
2989
      // do nothing ...
2990
    } else {
2991
      int64_t idx_cnt = access_idxs.count();
2992
      CK (OB_LIKELY(idx_cnt != 0));
2993
      if (T_SP_TYPE == sp_data_type_node->type_) {
2994
        if (ObObjAccessIdx::is_table_column(access_idxs)
2995
            || ObObjAccessIdx::is_local_variable(access_idxs)
2996
            || ObObjAccessIdx::is_package_variable(access_idxs)
2997
            || ObObjAccessIdx::is_subprogram_variable(access_idxs)) {
2998
          OZ (pl_type.deep_copy(resolve_ctx_.allocator_,
2999
                                ObObjAccessIdx::get_final_type(access_idxs)));
3000
          OX (pl_type.set_type_from_orgin(pl_type.get_type_from()));
3001
          OX (pl_type.set_type_from(PL_TYPE_ATTR_TYPE));
3002
          OZ (resolve_extern_type_info(resolve_ctx_.schema_guard_, access_idxs, extern_type_info));
3003
        } else {
3004
          ret = OB_ERR_TYPE_DECL_ILLEGAL;
3005
          LOG_WARN("PLS-00206: %TYPE must be applied to a variable, column, field or attribute",
3006
                   K(ret), K(access_idxs));
3007
        }
3008
      } else {
3009
        if (ObObjAccessIdx::is_table(access_idxs)) {
3010
          ObSQLSessionInfo &session_info = resolve_ctx_.session_info_;
3011
          ObSchemaGetterGuard &schema_guard = resolve_ctx_.schema_guard_;
3012
          uint64_t db_id = OB_INVALID_ID;
3013
          const ObTableSchema* table_schema = NULL;
3014
          ObRecordType *record_type = NULL;
3015
          ObSEArray<ObDataType, 8> types;
3016
          const uint64_t tenant_id = session_info.get_effective_tenant_id();
3017
          OZ (session_info.get_database_id(db_id));
3018
          OZ (schema_guard.get_table_schema(tenant_id, access_idxs.at(idx_cnt - 1).var_index_, table_schema));
3019
          CK (OB_NOT_NULL(table_schema));
3020
          if (OB_FAIL(ret)) {
3021
          } else if (with_rowid) {
3022
            // with_rowid的情况只可能是oracle模式下的trigger
3023
            // 将trigger package中routine的参数类型设置为 PL_TYPE_PACKAGE, 并加入到包头的type_table_中
3024
            ObSqlString record_name;
3025
            ObString record_name_str;
3026
            char* name_buf = NULL;
3027
            bool is_dup = false;
3028
            const void *dup_type = NULL;
3029
            const ObPLBlockNS *pre_ns = NULL;
3030
            CK (OB_NOT_NULL(current_block_));
3031
            CK (OB_NOT_NULL(pre_ns = current_block_->get_namespace().get_pre_ns()));
3032
            CK (access_idxs.count() > 0);
3033
            OZ (record_name.append_fmt(
3034
                "__trigger_param_type_%.*s",
3035
                access_idxs.at(0).var_name_.length(), access_idxs.at(0).var_name_.ptr()));
3036
            if (access_idxs.count() >= 2) {
3037
              OZ (record_name.append_fmt("_%.*s",
3038
                access_idxs.at(1).var_name_.length(), access_idxs.at(1).var_name_.ptr()));
3039
            }
3040
            if (OB_FAIL(ret)) {
3041
            } else if (OB_ISNULL(name_buf = static_cast<char*>(resolve_ctx_.allocator_.alloc(record_name.length() + 1)))) {
3042
              ret = OB_ALLOCATE_MEMORY_FAILED;
3043
              LOG_WARN("failed to allocate record name", K(ret));
3044
            } else {
3045
              record_name.to_string(name_buf, record_name.length() + 1);
3046
              record_name_str.assign_ptr(name_buf, record_name.length());
3047
              if (OB_FAIL(pre_ns->check_dup_type(record_name_str, is_dup, dup_type))) {
3048
                LOG_WARN("check dup type failed", K(record_name_str), K(is_dup), K(ret));
3049
              } else if (is_dup) {
3050
                if (OB_ISNULL(dup_type)) {
3051
                  ret = OB_ERR_UNEXPECTED;
3052
                  LOG_WARN("dup type is NULL", K(ret));
3053
                } else if (OB_SUCC(ret) && is_dup) {
3054
                  record_type = static_cast<ObRecordType *>(const_cast<void *>(dup_type));
3055
                  OV (OB_NOT_NULL(record_type));
3056
                  OX (pl_type.set_user_type_id(record_type->get_type(), record_type->get_user_type_id()));
3057
                  OZ (func.add_dependency_object(ObSchemaObjVersion(table_schema->get_table_id(),
3058
                      table_schema->get_schema_version(), ObDependencyTableType::DEPENDENCY_TABLE)));
3059
                }
3060
              } else {
3061
                OZ (build_record_type_by_schema(resolve_ctx_, table_schema, record_type, with_rowid));
3062
                CK (OB_NOT_NULL(record_type));
3063
                OX (record_type->set_name(record_name_str));
3064
                OZ (pre_ns->expand_data_type(record_type, types));
3065
                OZ (const_cast<ObPLBlockNS *>(pre_ns)->add_type(record_type));
3066
                OX (record_type->set_type_from(PL_TYPE_PACKAGE));
3067
                OX (pl_type.set_user_type_id(record_type->get_type(), record_type->get_user_type_id()));
3068
                OZ (pl_type.get_all_depended_user_type(resolve_ctx_, *pre_ns));
3069
                OZ (func.add_dependency_object(ObSchemaObjVersion(table_schema->get_table_id(),
3070
                        table_schema->get_schema_version(), ObDependencyTableType::DEPENDENCY_TABLE)));
3071
              }
3072
            }
3073
            OX (pl_type.set_type_from(PL_TYPE_PACKAGE));
3074
            OX (pl_type.set_type_from_orgin(PL_TYPE_PACKAGE));
3075
          } else {
3076
            OZ (build_record_type_by_schema(resolve_ctx_, table_schema, record_type, with_rowid));
3077
            CK (OB_NOT_NULL(record_type));
3078
            CK (OB_NOT_NULL(current_block_));
3079
            CK (OB_NOT_NULL(current_block_->get_namespace().get_type_table()));
3080
            OZ (current_block_->get_namespace().expand_data_type(record_type, types));
3081
            OZ (current_block_->get_namespace().get_type_table()->add_external_type(record_type));
3082
            OX (pl_type.set_user_type_id(record_type->get_type(), record_type->get_user_type_id()));
3083
            OX (pl_type.set_type_from_orgin(pl_type.get_type_from()));
3084
            OX (pl_type.set_type_from(PL_TYPE_ATTR_ROWTYPE));
3085
            OZ (pl_type.get_all_depended_user_type(resolve_ctx_, current_block_->get_namespace()));
3086
            OZ (resolve_extern_type_info(resolve_ctx_.schema_guard_, access_idxs, extern_type_info));
3087
            OZ (func.add_dependency_object(ObSchemaObjVersion(table_schema->get_table_id(),
3088
                      table_schema->get_schema_version(), ObDependencyTableType::DEPENDENCY_TABLE)));
3089
          }
3090
        } else if (ObObjAccessIdx::is_local_cursor_variable(access_idxs)
3091
                   || ObObjAccessIdx::is_local_refcursor_variable(access_idxs)
3092
                   || ObObjAccessIdx::is_subprogram_cursor_variable(access_idxs)
3093
                   || ObObjAccessIdx::is_package_cursor_variable(access_idxs)) {
3094
          const ObUserDefinedType* user_type = NULL;
3095
          const ObRecordType *record_type = NULL;
3096
          OX (pl_type.set_user_type_id(
3097
            PL_RECORD_TYPE, ObObjAccessIdx::get_final_type(access_idxs).get_user_type_id()));
3098
          CK (OB_NOT_NULL(current_block_));
3099
          OZ (current_block_->
3100
            get_namespace().get_pl_data_type_by_id(pl_type.get_user_type_id(), user_type));
3101
          CK (OB_NOT_NULL(user_type));
3102
          if (OB_SUCC(ret)) {
3103
            if (user_type->is_cursor_type() || user_type->is_sys_refcursor_type()) {
3104
              const ObRefCursorType *type = static_cast<const ObRefCursorType*>(user_type);
3105
              CK (OB_NOT_NULL(type));
3106
              OX (user_type = NULL);
3107
              OZ (current_block_->get_namespace().get_pl_data_type_by_id(type->get_return_type_id(), user_type));
3108
              CK (OB_NOT_NULL(user_type));
3109
              OX (pl_type.set_user_type_id(PL_RECORD_TYPE, type->get_return_type_id()));
3110
            }
3111
          }
3112
          CK (user_type->is_record_type());
3113
          CK (OB_NOT_NULL(record_type = static_cast<const ObRecordType*>(user_type)));
3114
          CK (OB_NOT_NULL(current_block_->get_namespace().get_type_table()));
3115
          OX ((const_cast<ObRecordType*>(record_type))->set_type_from(PL_TYPE_ATTR_ROWTYPE));
3116
          OZ (current_block_->get_namespace().get_type_table()->add_external_type(record_type));
3117
          OX (pl_type.set_type_from_orgin(pl_type.get_type_from()));
3118
          OX (pl_type.set_type_from(PL_TYPE_ATTR_ROWTYPE));
3119
          OZ (pl_type.get_all_depended_user_type(resolve_ctx_, current_block_->get_namespace()));
3120
          if (!ObObjAccessIdx::is_subprogram_cursor_variable(access_idxs)) {
3121
            OZ (resolve_extern_type_info(resolve_ctx_.schema_guard_, access_idxs, extern_type_info));
3122
          }
3123
        } else {
3124
          ret = OB_ERR_WRONG_ROWTYPE;
3125
          LOG_USER_ERROR(OB_ERR_WRONG_ROWTYPE,
3126
                         static_cast<int>(sp_data_type_node->str_len_), sp_data_type_node->str_value_);
3127
          LOG_WARN("PLS-00310: with %ROWTYPE attribute, ident must name a table, cursor or cursor-variable",
3128
                   K(ret), K(access_idxs));
3129
        }
3130
      }
3131
    }
3132
  }
3133
  CANCLE_LOG_CHECK_MODE();
3134
  return ret;
3135
}
3136

3137
// 注意: 该函数参考ObResolverUtils::resolve_data_type进行实现, 调整类型精度信息到默认值
3138
int ObPLResolver::adjust_routine_param_type(ObPLDataType &type)
3139
{
3140
  int ret = OB_SUCCESS;
3141
  if (type.is_obj_type() && !type.is_pl_integer_type() && OB_NOT_NULL(type.get_data_type())) {
3142
    ObDataType data_type = *(type.get_data_type());
3143
    const ObAccuracy &default_accuracy
3144
      = ObAccuracy::DDL_DEFAULT_ACCURACY2[true][data_type.get_obj_type()];
3145
    switch (data_type.get_type_class()) {
3146
      case ObIntTC:
3147
      case ObUIntTC: {
3148
        data_type.set_precision(default_accuracy.get_precision());
3149
        data_type.set_scale(0);
3150
      } break;
3151
      case ObFloatTC: {
3152
        data_type.set_precision(126);
3153
        data_type.set_scale(-1);
3154
      } break;
3155
      case ObDoubleTC: {
3156
        data_type.set_precision(-1);
3157
        data_type.set_scale(-85);
3158
      } break;
3159
      case ObNumberTC: {
3160
        data_type.set_precision(-1);
3161
        data_type.set_scale(-85);
3162
      } break;
3163
      case ObOTimestampTC: {
3164
        data_type.set_precision(
3165
          static_cast<int16_t>(default_accuracy.get_precision() + default_accuracy.get_scale()));
3166
        data_type.set_scale(default_accuracy.get_scale());
3167
      } break;
3168
      case ObDateTimeTC: {
3169
        data_type.set_precision(static_cast<int16_t>(default_accuracy.get_precision()));
3170
        data_type.set_scale(0);
3171
      } break;
3172
      case ObDateTC: {
3173
        data_type.set_precision(default_accuracy.get_precision());
3174
        data_type.set_scale(default_accuracy.get_scale());
3175
      } break;
3176
      case ObTimeTC: {
3177
        data_type.set_precision(default_accuracy.get_precision());
3178
        data_type.set_scale(default_accuracy.get_scale());
3179
      } break;
3180
      case ObYearTC: {
3181
        data_type.set_precision(default_accuracy.get_precision());
3182
        data_type.set_scale(default_accuracy.get_scale());
3183
      } break;
3184
      case ObStringTC: {
3185
        data_type.set_length(-1);
3186
      } break;
3187
      case ObRawTC: {
3188
        data_type.set_length(2000);
3189
      } break;
3190
      case ObLobTC:
3191
      case ObTextTC:
3192
      case ObJsonTC:
3193
      case ObGeometryTC: {
3194
        data_type.set_length(-1);
3195
        data_type.set_scale(default_accuracy.get_scale());
3196
      } break;
3197
      case ObBitTC: {
3198
        data_type.set_precision(default_accuracy.get_precision());
3199
        data_type.set_scale(default_accuracy.get_scale());
3200
      } break;
3201
      case ObIntervalTC: {
3202
        if (data_type.get_meta_type().is_interval_ym()) {
3203
          ObScale scale = ObIntervalScaleUtil::interval_ym_scale_to_ob_scale(9);
3204
          data_type.set_scale(scale);
3205
        } else {
3206
          ObScale scale = ObIntervalScaleUtil::interval_ds_scale_to_ob_scale(9, 9);
3207
          data_type.set_scale(scale);
3208
        }
3209
      } break;
3210
      case ObRowIDTC: {
3211
        if (ob_is_urowid(data_type.get_obj_type())) {
3212
          data_type.set_length(4000);
3213
        } else {
3214
          ret = OB_NOT_SUPPORTED;
3215
          LOG_WARN("only support urowid type for now", K(ret), K(data_type));
3216
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "non-urowid type");
3217
        }
3218
      } break;
3219
      case ObExtendTC:
3220
      default: {
3221
        // do nothing ...
3222
      } break;
3223
    }
3224
    OX (type.set_data_type(data_type));
3225
  }
3226
  return ret;
3227
}
3228

3229
int ObPLResolver::resolve_dblink_type(const ParseNode *node,
3230
                                      ObPLCompileUnitAST &func,
3231
                                      ObPLDataType &pl_type)
3232
{
3233
  int ret = OB_SUCCESS;
3234
  ParseNode *access_node = NULL;
3235
  ObString db_name;
3236
  ObString pkg_name;
3237
  ObString udt_name;
3238
  ObString dblink_name;
3239
  const ObUserDefinedType *udt = NULL;
3240
  CK (OB_LIKELY(2 == node->num_child_));
3241
  CK (OB_LIKELY(OB_NOT_NULL(node->children_[0])) && OB_LIKELY(OB_NOT_NULL(node->children_[1])));
3242
  CK (OB_LIKELY(T_SP_OBJ_ACCESS_REF == node->children_[0]->type_));
3243
  CK (OB_LIKELY(T_USER_VARIABLE_IDENTIFIER == node->children_[1]->type_));
3244
  CK (2 == node->children_[0]->num_child_);
3245
  CK (OB_NOT_NULL(access_node = node->children_[0]->children_[0]));
3246
  CK (T_SP_ACCESS_NAME == access_node->type_);
3247
  // access_node must be a package type.
3248
  CK (3 == access_node->num_child_);
3249
  CK (OB_NOT_NULL(access_node->children_[1]) && OB_NOT_NULL(access_node->children_[2]))
3250
  if (OB_SUCC(ret)) {
3251
    dblink_name.assign_ptr(node->children_[1]->str_value_,
3252
                           static_cast<int32_t>(node->children_[1]->str_len_));
3253
    pkg_name.assign_ptr(access_node->children_[1]->str_value_,
3254
                        static_cast<int32_t>(access_node->children_[1]->str_len_));
3255
    udt_name.assign_ptr(access_node->children_[2]->str_value_,
3256
                        static_cast<int32_t>(access_node->children_[2]->str_len_));
3257
    if (OB_NOT_NULL(access_node->children_[0])) {
3258
      db_name.assign_ptr(access_node->children_[0]->str_value_,
3259
                         static_cast<int32_t>(access_node->children_[0]->str_len_));
3260
    }
3261
  }
3262

3263
  OZ (resolve_dblink_type(dblink_name, db_name, pkg_name, udt_name, func, pl_type));
3264
  return ret;
3265
}
3266

3267
// for example :  'insert into tbl values (:NEW.rowid);'
3268
// this stmt may inside a trigger mock function body, :NEW is a type like tbl%ROWTYPE
3269
// in this case, we have to including the rowid psedocolumn in the result, regardless of
3270
// whether rowid is actual accessed or not.
3271
int ObPLResolver::resolve_sp_data_type(const ParseNode *sp_data_type_node,
3272
                                       const ObString &ident_name,
3273
                                       ObPLCompileUnitAST &func,
3274
                                       ObPLDataType &data_type,
3275
                                       ObPLExternTypeInfo *extern_type_info,
3276
                                       bool with_rowid,
3277
                                       bool is_for_param_type)
3278
{
3279
  int ret = OB_SUCCESS;
3280

3281
  SET_LOG_CHECK_MODE();
3282

3283
  bool need_adjust_type = false;
3284
  CK (OB_NOT_NULL(sp_data_type_node));
3285
  CK (OB_NOT_NULL(current_block_));
3286
  if (OB_SUCC(ret)) {
3287
    if (T_SP_OBJ_ACCESS_REF == sp_data_type_node->type_) {
3288
      OZ (resolve_sp_composite_type(sp_data_type_node, func, data_type, extern_type_info));
3289
    } else if (T_SP_TYPE == sp_data_type_node->type_
3290
               || T_SP_ROWTYPE == sp_data_type_node->type_) {
3291
      OZ (resolve_sp_row_type(sp_data_type_node, func, data_type, extern_type_info, with_rowid));
3292
    } else if (T_SP_DBLINK_TYPE == sp_data_type_node->type_) {
3293
      OZ (resolve_dblink_type(sp_data_type_node, func, data_type));
3294
    } else {
3295
      OZ (resolve_sp_scalar_type(resolve_ctx_.allocator_,
3296
                                 sp_data_type_node,
3297
                                 ident_name,
3298
                                 resolve_ctx_.session_info_,
3299
                                 data_type,
3300
                                 is_for_param_type,
3301
                                 get_current_namespace().get_package_id()));
3302
    }
3303
  }
3304

3305
  OX (need_adjust_type = data_type.is_subtype() || data_type.is_type_type());
3306
#ifdef OB_BUILD_ORACLE_PL
3307
  OZ (current_block_->get_namespace().get_subtype_actually_basetype(data_type));
3308
#endif
3309
  /*!
3310
   * for number(38,0), always adjust presicion and scale. example:
3311
   * declare
3312
   *   subtype st is number(38,0);
3313
   *   function func(x st) return st is begin dbms_output.put_line(x); return x; end;
3314
   * begin
3315
   *   dbms_output.put_line(func(.66));
3316
   * end;
3317
   * output is 0.66, 0.66
3318
   */
3319
  if (OB_SUCC(ret)
3320
      && OB_NOT_NULL(extern_type_info)
3321
      && ObNumberType == data_type.get_obj_type()
3322
      && 38 == data_type.get_data_type()->get_precision()
3323
      && 0 == data_type.get_data_type()->get_scale()) {
3324
    OZ (adjust_routine_param_type(data_type));
3325
  }
3326
  // datatype is parameter type if extern_type_info is not null, need adjust presicion and scale etc...
3327
  if (OB_SUCC(ret) && OB_NOT_NULL(extern_type_info) && need_adjust_type) {
3328
    // it`s return type when ident_name is empty.
3329
    // if return is numeric type, do not adjust it. (Compatible Oracle)
3330
    if (ident_name.empty() && ob_is_numeric_type(data_type.get_obj_type())) {
3331
      // do nothing ...
3332
    } else {
3333
      OZ (adjust_routine_param_type(data_type));
3334
    }
3335
  }
3336

3337
  CANCLE_LOG_CHECK_MODE();
3338

3339
  return ret;
3340
}
3341

3342
#ifdef OB_BUILD_ORACLE_PL
3343
int ObPLResolver::resolve_declare_collection_type(const ParseNode *type_node,
3344
                                                  ObPLDeclareUserTypeStmt *stmt,
3345
                                                  ObPLCompileUnitAST &unit_ast)
3346
{
3347
  UNUSED(unit_ast);
3348
  int ret = OB_SUCCESS;
3349
  if (OB_ISNULL(type_node)) {
3350
    ret = OB_INVALID_ARGUMENT;
3351
    LOG_WARN("type node is null");
3352
  } else if (OB_UNLIKELY(type_node->num_child_ != 2)) {
3353
    ret = OB_ERR_UNEXPECTED;
3354
    LOG_WARN("type node is invalid", K(type_node->num_child_));
3355
  } else {
3356
    const ParseNode *name_node = type_node->children_[0];
3357
    const ParseNode *coll_type_def = type_node->children_[1];
3358
    ObString table_name;
3359
    ObPLDataType element_type;
3360
    ObCollectionType *collection_type = NULL;
3361
    void *ptr = NULL;
3362
    if (OB_ISNULL(name_node) || OB_ISNULL(coll_type_def)) {
3363
      ret = OB_ERR_UNEXPECTED;
3364
      LOG_WARN("parse node is invalid", K(name_node), K(coll_type_def));
3365
    } else {
3366
      table_name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));
3367
      const ParseNode *elem_type_node = coll_type_def->children_[0];
3368
      if (OB_FAIL(resolve_sp_data_type(elem_type_node, table_name, unit_ast, element_type))) {
3369
        LOG_WARN("resolve sp data type failed", K(ret));
3370
      } else if (element_type.is_cursor_type()) {
3371
        ret = OB_ERR_INDEX_TABLE_OF_CURSOR;
3372
        LOG_WARN("Index Tables of Cursor Variables are disallowed", K(ret), K(element_type));
3373
      }
3374

3375
#define ALLOC_COLLECTION_TYPE(TYPE) \
3376
  do { \
3377
     if (OB_SUCC(ret)) { \
3378
       TYPE *table_type = NULL; \
3379
       if (OB_ISNULL(ptr = resolve_ctx_.allocator_.alloc(sizeof(TYPE)))) { \
3380
         ret = OB_ALLOCATE_MEMORY_FAILED; \
3381
         LOG_WARN("no memory to allocate ObTableType", "size", sizeof(TYPE)); \
3382
       } else { \
3383
         table_type = new(ptr) TYPE(); \
3384
         collection_type = table_type; \
3385
       } \
3386
     } \
3387
  } while (0)
3388

3389
      switch (coll_type_def->type_) {
3390
      case T_SP_NESTED_TABLE_TYPE: {
3391

3392
        ALLOC_COLLECTION_TYPE(ObNestedTableType);
3393

3394
      }
3395
        break;
3396
      case T_SP_ASSOC_ARRAY_TYPE: {
3397

3398
        ALLOC_COLLECTION_TYPE(ObAssocArrayType);
3399

3400
        if (OB_SUCC(ret)) {
3401
          ObPLDataType index_type;
3402
          const ParseNode *index_type_node = coll_type_def->children_[1];
3403
          if (OB_FAIL(resolve_sp_data_type(index_type_node, table_name, unit_ast, index_type))) {
3404
            LOG_WARN("resolve sp data type failed", K(ret));
3405
          } else if (!index_type.is_pl_integer_type()
3406
                     && index_type.get_obj_type() != ObVarcharType) {
3407
              ret = OB_ERR_UNSUPPORTED_TABLE_INDEX_TYPE;
3408
              LOG_WARN("PLS-00315: Implementation restriction: unsupported table index type",
3409
                       K(index_type), K(ret));
3410
          } else {
3411
            static_cast<ObAssocArrayType*>(collection_type)->set_index_type(index_type);
3412
          }
3413
        }
3414
      }
3415
        break;
3416
      case T_SP_VARRAY_TYPE: {
3417

3418
        ALLOC_COLLECTION_TYPE(ObVArrayType);
3419

3420
        if (OB_SUCC(ret)) {
3421
          const ParseNode *size_node = coll_type_def->children_[1];
3422
          CK (OB_NOT_NULL(size_node));
3423
          CK (T_INT == size_node->type_);
3424
          if (OB_SUCC(ret)) {
3425
            if (size_node->value_ > 0) {
3426
              static_cast<ObVArrayType*>(collection_type)->set_capacity(size_node->value_);
3427
            } else {
3428
              ret = OB_ERR_ARRAY_MUST_HAVE_POSITIVE_LIMIT;
3429
              LOG_WARN("PLS-00537: A VARRAY must have a positive limit", K(size_node->value_), K(ret));
3430
            }
3431
          }
3432
        }
3433
      }
3434
        break;
3435
      default: {
3436
        ret = OB_ERR_UNEXPECTED;
3437
        LOG_WARN("collection type is invalid", K_(coll_type_def->type));
3438
      }
3439
        break;
3440
      }
3441

3442
      if (OB_SUCC(ret)) {
3443
        if (element_type.is_not_null() && -1 == coll_type_def->value_) {
3444
          ret = OB_ERR_SUBTYPE_NOTNULL_MISMATCH;
3445
          LOG_WARN("PLS-00366: subtype of a not null type must also be not null", K(ret));
3446
        } else {
3447
          element_type.set_not_null(coll_type_def->value_ == 1 || element_type.get_not_null());
3448
        }
3449
      }
3450

3451
      if (OB_SUCC(ret)) {
3452
        collection_type->set_element_type(element_type);
3453
        collection_type->set_name(table_name);
3454
        if (unit_ast.is_package()) {
3455
          collection_type->set_type_from(PL_TYPE_PACKAGE);
3456
        }
3457
        if (OB_FAIL(current_block_->get_namespace().add_type(collection_type))) {
3458
          LOG_WARN("failed to add table type to type table", K(*collection_type), K(ret));
3459
        } else {
3460
          if (!OB_ISNULL(stmt)) {
3461
            stmt->set_user_type(collection_type);
3462
          }
3463
        }
3464
      }
3465
    }
3466
  }
3467
  return ret;
3468
}
3469

3470
int ObPLResolver::check_collection_constructor(const ParseNode *node, const ObString &type_name, bool &is_constructor)
3471
{
3472
  int ret = OB_SUCCESS;
3473
  is_constructor = false;
3474
  if (OB_NOT_NULL(node)
3475
      && T_OBJ_ACCESS_REF == node->type_
3476
      && 2 == node->num_child_
3477
      && OB_NOT_NULL(node->children_[0])
3478
      && OB_ISNULL(node->children_[1])
3479
      && T_FUN_SYS == node->children_[0]->type_
3480
      && 1 == node->children_[0]->num_child_) {
3481
    const ParseNode *name_node = node->children_[0]->children_[0];
3482
    CK (OB_NOT_NULL(name_node));
3483
    if (OB_SUCC(ret)) {
3484
      ObString func_name(static_cast<int32_t>(name_node->str_len_), name_node->str_value_);
3485
      is_constructor = ObCharset::case_insensitive_equal(func_name, type_name);
3486
      if (is_constructor && node->children_[1] != NULL) {
3487
        ret = OB_NOT_SUPPORTED;
3488
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "Collection constructor with obj access");
3489
      }
3490
    }
3491
  }
3492
  return ret;
3493
}
3494
#endif
3495

3496
int ObPLResolver::resolve_declare_var(const ObStmtNodeTree *parse_tree, ObPLDeclareVarStmt *stmt, ObPLFunctionAST &func)
3497
{
3498
  int ret = OB_SUCCESS;
3499
  ObPLCompileUnitAST &unit_ast = static_cast<ObPLCompileUnitAST&>(func);
3500
  if (OB_FAIL(check_declare_order(PL_VAR))) {
3501
    LOG_WARN("fail to check decalre order", K(ret));
3502
  } else {
3503
    ret = resolve_declare_var_comm(parse_tree, stmt, unit_ast);
3504
  }
3505
  return ret;
3506
}
3507

3508
int ObPLResolver::resolve_declare_var(const ObStmtNodeTree *parse_tree, ObPLPackageAST &package_ast)
3509
{
3510
  int ret = OB_SUCCESS;
3511
  ObPLCompileUnitAST &unit_ast = static_cast<ObPLCompileUnitAST&>(package_ast);
3512
  ret = resolve_declare_var_comm(parse_tree, NULL, unit_ast);
3513
  return ret;
3514
}
3515

3516
int ObPLResolver::resolve_declare_var_comm(const ObStmtNodeTree *parse_tree,
3517
                                           ObPLDeclareVarStmt *stmt,
3518
                                           ObPLCompileUnitAST &unit_ast)
3519
{
3520
  int ret = OB_SUCCESS;
3521
  CK (OB_NOT_NULL(parse_tree));
3522
  CK (OB_LIKELY(3 == parse_tree->num_child_));
3523
  CK (OB_NOT_NULL(current_block_));
3524
  if (OB_SUCC(ret)) {
3525
    bool not_null = parse_tree->int32_values_[0] == 1;
3526
    bool constant = parse_tree->int32_values_[1] == 1;
3527

3528
    ObPLDataType data_type;
3529
    ObString ident_name;
3530
    ObRawExpr *default_expr = NULL;
3531
    bool default_construct = false;
3532
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
3533
    const ObStmtNodeTree *type_node = parse_tree->children_[1];
3534
    const ObStmtNodeTree *default_node = parse_tree->children_[2];
3535
    ObSEArray<ObString, 1> names;
3536

3537
    // resolve ident name first, for report error message.
3538
    CK (OB_NOT_NULL(name_node));
3539
    CK (name_node->num_child_ > 0);
3540
    CK (OB_NOT_NULL(name_node->children_[0]));
3541
    OZ (resolve_ident(name_node->children_[0], ident_name));
3542

3543
    // resolve variable type
3544
    CK (OB_NOT_NULL(type_node));
3545
    OZ (resolve_sp_data_type(type_node, ident_name, unit_ast, data_type));
3546

3547
    if (OB_SUCC(ret)) {
3548
      if (data_type.is_not_null() && -1 == parse_tree->int32_values_[0]) {
3549
        ret = OB_ERR_SUBTYPE_NOTNULL_MISMATCH;
3550
        LOG_WARN("PLS-00366: subtype of a not null type must also be not null", K(ret));
3551
      } else {
3552
        OX (not_null = not_null || data_type.get_not_null());
3553
      }
3554
    }
3555
    OX (data_type.set_not_null(not_null));
3556

3557
    if (OB_SUCC(ret) && data_type.is_cursor_type() && unit_ast.is_package()) {
3558
      ret = OB_ERR_CURSOR_VAR_IN_PKG;
3559
      LOG_WARN("PLS-00994: Cursor Variables cannot be declared as part of a package",
3560
               K(ret), K(data_type));
3561
    }
3562

3563
    // resolve defalut value
3564
    if (OB_SUCC(ret)) {
3565
      if (OB_ISNULL(default_node)) {
3566
        if (constant) {
3567
          ret = OB_ERR_INIT_CONST_ILLEGAL;
3568
          LOG_WARN("PLS-00322: Constant declarations should contain initialization assignments",
3569
                   K(ret), K(constant), K(default_node));
3570
          LOG_USER_ERROR(OB_ERR_INIT_CONST_ILLEGAL, ident_name.length(), ident_name.ptr());
3571
        } else if (not_null) {
3572
          ret = OB_ERR_INIT_NOTNULL_ILLEGAL;
3573
          LOG_WARN("PLS-00218: a variable declared NOT NULL must have an initialization assignment",
3574
                   K(ret), K(not_null), K(default_node));
3575
        }
3576
      }
3577
      if (OB_NOT_NULL(default_node)) { // 默认值的not null检查在执行期做, 这里仅解析默认值表达式
3578
        CK (OB_LIKELY(T_SP_DECL_DEFAULT == default_node->type_));
3579
        CK (OB_NOT_NULL(default_node->children_[0]));
3580

3581
        if (OB_SUCC(ret) && not_null && T_NULL == default_node->children_[0]->type_) {
3582
	        ret = OB_ERR_EXPRESSION_WRONG_TYPE;
3583
          LOG_WARN("PLS-00382: expression is of wrong type", K(ret));
3584
        }
3585
        if (OB_SUCC(ret) && not_null && T_QUESTIONMARK == default_node->children_[0]->type_) {
3586
          int64_t idx = default_node->children_[0]->value_;
3587
          const ObPLVar* var = current_block_->get_symbol_table()->get_symbol(idx);
3588
          if (NULL != var &&
3589
              0 == var->get_name().case_compare(ObPLResolver::ANONYMOUS_ARG) &&
3590
              NULL != var->get_pl_data_type().get_data_type() &&
3591
              ObNullType == var->get_pl_data_type().get_data_type()->get_obj_type()) {
3592
            ret = OB_ERR_EXPRESSION_WRONG_TYPE;
3593
            LOG_WARN("PLS-00382: expression is of wrong type", K(ret));
3594
          }
3595
        }
3596

3597
        OZ (resolve_expr(default_node->children_[0], unit_ast, default_expr,
3598
                         combine_line_and_col(default_node->children_[0]->stmt_loc_),
3599
                         true, &data_type));
3600
        if (OB_SUCC(ret)) {
3601
          if (T_FUN_PL_COLLECTION_CONSTRUCT == default_expr->get_expr_type()
3602
              && 0 == default_expr->get_param_count()) {
3603
            if (OB_NOT_NULL(stmt)) {
3604
              stmt->set_default(PL_CONSTRUCT_COLLECTION);
3605
            }
3606
            default_construct = true;
3607
          } else {
3608
            if (OB_NOT_NULL(stmt)) {
3609
              stmt->set_default(unit_ast.get_expr_count() - 1);
3610
            }
3611
          }
3612
        }
3613
      } else if (OB_NOT_NULL(data_type.get_data_type())) { // 基础类型如果, 没有默认值, 设置为NULL
3614
        OZ (ObRawExprUtils::build_null_expr(expr_factory_, default_expr));
3615
        CK (OB_NOT_NULL(default_expr));
3616
        OZ (ObRawExprUtils::build_column_conv_expr(&resolve_ctx_.session_info_,
3617
                                                   expr_factory_,
3618
                                                   data_type.get_data_type()->get_obj_type(),
3619
                                                   data_type.get_data_type()->get_collation_type(),
3620
                                                   data_type.get_data_type()->get_accuracy_value(),
3621
                                                   true,
3622
                                                   NULL, /*"db_name"."tb_name"."col_name"*/
3623
                                                   &data_type.get_type_info(),
3624
                                                   default_expr,
3625
                                                   true /*is_in_pl*/));
3626
        CK (OB_NOT_NULL(default_expr));
3627
        OZ (formalize_expr(*default_expr));
3628
        OZ (unit_ast.add_expr(default_expr));
3629
        if (OB_SUCC(ret) && OB_NOT_NULL(stmt)) {
3630
          stmt->set_default(unit_ast.get_expr_count() - 1);
3631
        }
3632
      } else {
3633
        if (OB_SUCC(ret) && OB_NOT_NULL(stmt) && data_type.is_associative_array_type()) {
3634
          stmt->set_default(PL_CONSTRUCT_COLLECTION);
3635
        }
3636
      }
3637
    }
3638

3639
    if (OB_SUCC(ret)) {
3640
      ObString name;
3641
      CK (OB_NOT_NULL(name_node));
3642
      for (int64_t i = 0; OB_SUCC(ret) && i < name_node->num_child_; ++i) {
3643
        name.reset();
3644
        if (OB_UNLIKELY(name_node->children_[i]->str_len_ > 
3645
          (lib::is_oracle_mode() ? OB_MAX_PL_IDENT_LENGTH : OB_MAX_MYSQL_PL_IDENT_LENGTH))) {
3646
          ret = OB_ERR_IDENTIFIER_TOO_LONG;
3647
          LOG_USER_ERROR(OB_ERR_IDENTIFIER_TOO_LONG,
3648
                         static_cast<int32_t>(name_node->children_[i]->str_len_),
3649
                         name_node->children_[i]->str_value_);
3650
          LOG_WARN("identifier too long", K(name_node->children_[i]->str_value_));
3651
        }
3652
        OZ (resolve_ident(name_node->children_[i], name));
3653
        if (OB_SUCC(ret) && OB_NOT_NULL(stmt)) {
3654
          OZ (stmt->add_index(unit_ast.get_symbol_table().get_count()));
3655
        }
3656
        OZ (current_block_->get_namespace().add_symbol(
3657
              name, data_type, default_expr, constant, not_null, default_construct));
3658
      }
3659
    }
3660
  }
3661
  return ret;
3662
}
3663

3664
int ObPLResolver::is_return_ref_cursor_type(const ObRawExpr *expr, bool &is_ref_cursor_type)
3665
{
3666
  int ret = OB_SUCCESS;
3667
  is_ref_cursor_type = false;
3668
  CK (OB_NOT_NULL(expr));
3669
  if (OB_SUCC(ret)) {
3670
    const ObPLDataType *src_type = NULL;
3671
    ObPLDataType type_local;
3672
    if (expr->is_const_raw_expr()) {
3673
      const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(expr);
3674
      const ObPLSymbolTable* symbol_table = NULL;
3675
      const ObPLVar* var = NULL;
3676
      if (!const_expr->get_value().is_unknown()) {
3677
        // ret = OB_ERR_UNEXPECTED;
3678
        // do nothing, may be something like( return 1; )
3679
        // LOG_WARN("const expr", K(const_expr->get_value()), K(current_block_), K(ret));
3680
      } else if (OB_ISNULL(current_block_)
3681
              || OB_ISNULL(symbol_table = current_block_->get_symbol_table())) {
3682
        ret = OB_ERR_UNEXPECTED;
3683
        LOG_WARN("unexpected null", K(current_block_), K(ret));
3684
      } else if (OB_ISNULL(var = symbol_table->get_symbol(const_expr->get_value().get_unknown()))) {
3685
        ret = OB_ERR_UNEXPECTED;
3686
        LOG_WARN("get symble var is null", K(var),
3687
                                           K(const_expr->get_value().get_unknown()), K(ret));
3688
      } else if (var->get_name().case_compare("\"anonymous argument\"") != 0) {
3689
        src_type = &(var->get_type());
3690
        if (src_type->is_ref_cursor_type()) {
3691
          is_ref_cursor_type = true;
3692
        }
3693
      }
3694
    } else if (expr->is_obj_access_expr()) {
3695
      OZ (static_cast<const ObObjAccessRawExpr*>(expr)->get_final_type(type_local));
3696
      OX (src_type = &type_local);
3697
      if (OB_SUCC(ret) && src_type->is_ref_cursor_type()) {
3698
        is_ref_cursor_type = true;
3699
      }
3700
    } else if (expr->is_udf_expr()) {
3701
      const ObUDFRawExpr *udf_expr = static_cast<const ObUDFRawExpr *>(expr);
3702
      if (udf_expr->get_is_return_sys_cursor()) {
3703
        is_ref_cursor_type = true;
3704
      }
3705
    }
3706
  }
3707
  return ret;
3708
}
3709

3710
int ObPLResolver::check_assign_type(const ObPLDataType &dest_data_type, const ObRawExpr *right_expr)
3711
{
3712
  int ret = OB_SUCCESS;
3713
  CK (OB_NOT_NULL(right_expr));
3714
  if (OB_SUCC(ret)) {
3715
    if (dest_data_type.is_cursor_var()) { // cursor var cant be left value
3716
      ret = OB_ERR_CURSOR_LEFT_ASSIGN;
3717
      LOG_WARN("local cursor cann't be assign left", K(ret));
3718
    } else if (dest_data_type.is_cursor_type()) {
3719
      bool is_ref_cursor_type = false;
3720
      OZ (is_return_ref_cursor_type(right_expr, is_ref_cursor_type));
3721
      if (OB_SUCC(ret) && !is_ref_cursor_type && T_NULL != right_expr->get_expr_type()) {
3722
        ret = OB_ERR_EXP_NEED_SAME_DATATYPE;
3723
        LOG_WARN("expression wrong type", K(ret));
3724
      }
3725
    } else {
3726
      // do nothing
3727
    }
3728
  }
3729
  return ret;
3730
}
3731

3732
int ObPLResolver::resolve_question_mark_node(
3733
  const ObStmtNodeTree *into_node, ObRawExpr *&into_expr)
3734
{
3735
  int ret = OB_SUCCESS;
3736
  ObConstRawExpr *expr = NULL;
3737
  const ObPLVar *var = NULL;
3738
  CK (OB_NOT_NULL(current_block_->get_symbol_table()));
3739
  CK (OB_NOT_NULL(var = current_block_->get_symbol_table()->get_symbol(into_node->value_)));
3740
  CK (var->get_name().prefix_match(ANONYMOUS_ARG));
3741
  if (NULL != var && var->is_readonly() && var->is_referenced()) {
3742
    OX (const_cast<ObPLVar*>(var)->set_name(ANONYMOUS_INOUT_ARG));
3743
  }
3744
  OZ (expr_factory_.create_raw_expr(T_QUESTIONMARK, expr));
3745
  CK (OB_NOT_NULL(expr));
3746
  if (OB_SUCC(ret)) {
3747
    ObObjParam val;
3748
    ObExprResType type;
3749
    val.set_unknown(into_node->value_);
3750
    val.set_param_meta();
3751
    expr->set_value(val);
3752
    type.set_null();
3753
    expr->set_result_type(type);
3754
    OZ (expr->extract_info());
3755
    OX (into_expr = expr);
3756
  }
3757
  return ret;
3758
}
3759

3760
bool ObPLResolver::is_question_mark_value(ObRawExpr *into_expr, ObPLBlockNS *ns)
3761
{
3762
  bool ret = false;
3763
  if (OB_NOT_NULL(into_expr)
3764
      && T_QUESTIONMARK == into_expr->get_expr_type()
3765
      && (static_cast<ObConstRawExpr *>(into_expr))->get_value().is_unknown()
3766
      && OB_NOT_NULL(ns)
3767
      && OB_NOT_NULL(ns->get_symbol_table())) {
3768
    const ObPLVar *var = NULL;
3769
    int64_t idx = (static_cast<ObConstRawExpr *>(into_expr))->get_value().get_unknown();
3770
    if (OB_NOT_NULL(var = ns->get_symbol_table()->get_symbol(idx))) {
3771
      if (var->get_name().prefix_match(ANONYMOUS_ARG)) {
3772
        ret = true;
3773
      }
3774
    }
3775
  }
3776
  return ret;
3777
}
3778

3779
int ObPLResolver::set_question_mark_type(ObRawExpr *into_expr, ObPLBlockNS *ns, const ObPLDataType *type)
3780
{
3781
  int ret = OB_SUCCESS;
3782
  ObConstRawExpr *const_expr = NULL;
3783
  const ObPLVar *var = NULL;
3784
  ObExprResType res_type;
3785
  CK (OB_NOT_NULL(into_expr));
3786
  CK (OB_NOT_NULL(type));
3787
  CK (OB_NOT_NULL(ns));
3788
  CK (T_QUESTIONMARK == into_expr->get_expr_type());
3789
  CK (OB_NOT_NULL(const_expr = static_cast<ObConstRawExpr*>(into_expr)));
3790
  CK (OB_NOT_NULL(ns->get_symbol_table()));
3791
  CK (OB_NOT_NULL(var = ns->get_symbol_table()->get_symbol(const_expr->get_value().get_unknown())));
3792
  CK (var->get_name().prefix_match(ANONYMOUS_ARG));
3793
  OX ((const_cast<ObPLVar*>(var))->set_type(*type));
3794
  OX ((const_cast<ObPLVar*>(var))->set_readonly(false));
3795
  if (OB_FAIL(ret)) {
3796
  } else if (type->is_obj_type()) {
3797
    CK (OB_NOT_NULL(type->get_data_type()));
3798
    OX (res_type.set_meta(type->get_data_type()->get_meta_type()));
3799
    OX (res_type.set_accuracy(type->get_data_type()->get_accuracy()));
3800
  } else {
3801
    OX (res_type.set_ext());
3802
    OX (res_type.set_extend_type(type->get_type()));
3803
    OX (res_type.set_udt_id(type->get_user_type_id()));
3804
  }
3805
  OX (into_expr->set_result_type(res_type));
3806
  return ret;
3807
}
3808

3809
int ObPLResolver::resolve_assign(const ObStmtNodeTree *parse_tree, ObPLAssignStmt *stmt, ObPLFunctionAST &func)
3810
{
3811
  int ret = OB_SUCCESS;
3812
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
3813
    ret = OB_INVALID_ARGUMENT;
3814
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
3815
  } else {
3816
    for (int64_t i = 0; OB_SUCC(ret) && i < parse_tree->num_child_; ++i) {
3817
      if (OB_ISNULL(parse_tree->children_[i])) {
3818
        LOG_WARN("invalid assign stmt", K(parse_tree->children_[i]), K(ret));
3819
      } else if (T_VAR_VAL != parse_tree->children_[i]->type_) {
3820
        ret = OB_ERR_UNEXPECTED;
3821
        LOG_WARN("invalid assign stmt", K(parse_tree->children_[i]->type_), K(ret));
3822
      } else {
3823
        //解析into expr
3824
        ObRawExpr *into_expr = NULL;
3825
        const ObStmtNodeTree *into_node = parse_tree->children_[i]->children_[0];
3826
        ObQualifiedName q_name;
3827
        bool need_expect_type = true;
3828
        if (T_SP_OBJ_ACCESS_REF == into_node->type_/*Oracle mode*/) {
3829
          if (OB_FAIL(resolve_obj_access_idents(*into_node, q_name.access_idents_, func))) {
3830
            LOG_WARN("resolve pl obj access ident failed", K(ret));
3831
          }
3832
        } else if (T_QUESTIONMARK == into_node->type_/*Oracle mode*/) {
3833
          OZ (resolve_question_mark_node(into_node, into_expr));
3834
        } else if (OB_FAIL(ObResolverUtils::resolve_obj_access_ref_node(expr_factory_,
3835
                            into_node, q_name, resolve_ctx_.session_info_))) {
3836
          LOG_WARN("resolve obj access ref node failed", K(ret));
3837
        }
3838
        if (OB_SUCC(ret)) {
3839
          if (T_SYSTEM_VARIABLE == into_node->type_) {
3840
            q_name.access_idents_.at(0).access_index_ =
3841
                ObSetVar::SET_SCOPE_GLOBAL == static_cast<ObSetVar::SetScopeType>(parse_tree->children_[i]->value_)
3842
                ? pl::ObPLExternalNS::GLOBAL_VAR : pl::ObPLExternalNS::SESSION_VAR;
3843
          } else if (T_USER_VARIABLE_IDENTIFIER == into_node->type_) {
3844
            q_name.access_idents_.at(0).access_index_ = pl::ObPLExternalNS::USER_VAR;
3845
          }
3846
        }
3847
        if (OB_SUCC(ret) && OB_ISNULL(into_expr)) {
3848
          OZ (resolve_var(q_name, func, into_expr, true/*for write*/));
3849
          if (OB_ERR_VARIABLE_IS_READONLY == ret) {
3850
            ret = OB_ERR_EXP_NOT_ASSIGNABLE;
3851
            LOG_USER_ERROR(OB_ERR_EXP_NOT_ASSIGNABLE,
3852
                           static_cast<int>(into_node->str_len_), into_node->str_value_);
3853
          }
3854
          CK (OB_NOT_NULL(into_expr));
3855
        }
3856
        if (OB_SUCC(ret)) {
3857
          if (T_OP_GET_SYS_VAR == into_expr->get_expr_type()
3858
              || T_OP_GET_USER_VAR == into_expr->get_expr_type()) {
3859
            // 对于系统变量和用户变量的赋值, PL通过SPI构造SET @VAR = VALUE;语句, 然后交由SQL引擎执行
3860
            // 虽然系统变量的类型是确定的，但是这里也不应该将VALUE的结果强转为系统变量的类型
3861
            // 原因是系统变量支持类型SET AUTOCOMMIT=ON;这种写法，而AUTOCOMMIT的类型是BOOL
3862
            // ON显然不支持转为BOOL类型
3863
            // 对于用户变量的赋值，用户变量类型会随着赋值结果的类型而改变，因此这里也不能强转
3864
            need_expect_type = false;
3865
            if (T_OP_GET_SYS_VAR == into_expr->get_expr_type()) {
3866
              ObString var_name(into_node->str_len_, into_node->str_value_);
3867
              if (OB_UNLIKELY(0 == var_name.case_compare("autocommit"))) {
3868
                if (func.is_function() || resolve_ctx_.session_info_.is_for_trigger_package()) {
3869
                  ret = OB_ER_SP_CANT_SET_AUTOCOMMIT;
3870
                  LOG_USER_ERROR(OB_ER_SP_CANT_SET_AUTOCOMMIT);
3871
                  LOG_WARN("Not allowed to set autocommit from a stored function or trigger",
3872
                          K(ret), K(var_name));
3873
                } else {
3874
                  func.set_has_set_autocommit_stmt();
3875
                }
3876
              }
3877
            } 
3878
          } else if (into_expr->is_obj_access_expr()) {
3879
            OZ (func.add_obj_access_expr(into_expr), into_expr);
3880
          }
3881

3882
          OZ (func.add_expr(into_expr), into_expr);
3883
          OZ (stmt->add_into(func.get_expr_count() - 1));
3884
        }
3885

3886
        // 解析value expr
3887
        if (OB_SUCC(ret)) {
3888
          ObRawExpr *value_expr = NULL;
3889
          const ObStmtNodeTree *value_node = parse_tree->children_[i]->children_[1];
3890
          if (OB_ISNULL(value_node)) {
3891
            ret = OB_ERR_UNEXPECTED;
3892
            LOG_WARN("value node is NULL", K(value_node), K(ret));
3893
          } else {
3894
            const ObPLDataType *expected_type = NULL;
3895
            ObPLDataType expected_type_local;
3896
            uint64_t package_id = OB_INVALID_ID;
3897
            uint64_t subprogram_id = OB_INVALID_ID;
3898
            int64_t var_idx = OB_INVALID_INDEX;
3899
            const ObPLVar* var = NULL;
3900
            if (into_expr->is_const_raw_expr()) {
3901
              const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(into_expr);
3902
              const ObPLSymbolTable* symbol_table = NULL;
3903
              const ObPLVar* var = NULL;
3904
              CK (const_expr->get_value().is_unknown());
3905
              CK (OB_NOT_NULL(current_block_));
3906
              CK (OB_NOT_NULL(symbol_table = current_block_->get_symbol_table()));
3907
              CK (OB_NOT_NULL(var = symbol_table->get_symbol(const_expr->get_value().get_unknown())));
3908
              if (OB_FAIL(ret)) {
3909
                // do nothing
3910
              } else if (var->get_name().prefix_match(ANONYMOUS_ARG)) {
3911
                if (!var->is_readonly()) {
3912
                  const_cast<ObPLVar*>(var)->set_name(ANONYMOUS_INOUT_ARG);
3913
                }
3914
              } else {
3915
                expected_type = &(var->get_type());
3916
              }
3917
            } else if (into_expr->is_obj_access_expr()) {
3918
              OZ (static_cast<const ObObjAccessRawExpr*>(into_expr)->get_final_type(expected_type_local));
3919
              OX (expected_type = &expected_type_local);
3920
            } else if (T_OP_GET_PACKAGE_VAR == into_expr->get_expr_type()) {
3921
              CK (into_expr->get_param_count() >= 3);
3922
              OX (package_id = static_cast<const ObConstRawExpr *>(into_expr->get_param_expr(0))->get_value().get_uint64());
3923
              OX (var_idx = static_cast<const ObConstRawExpr *>(into_expr->get_param_expr(1))->get_value().get_int());
3924
              OZ (current_block_->get_namespace().get_package_var(resolve_ctx_, package_id, var_idx, var));
3925
              CK (OB_NOT_NULL(var));
3926
              OX (expected_type = &(var->get_type()));
3927
              OX (func.set_wps());
3928
            } else if (T_OP_GET_SUBPROGRAM_VAR == into_expr->get_expr_type()) {
3929
              CK (into_expr->get_param_count() >= 3);
3930
              OX (subprogram_id = static_cast<const ObConstRawExpr *>(into_expr->get_param_expr(1))->get_value().get_uint64());
3931
              OX (var_idx = static_cast<const ObConstRawExpr *>(into_expr->get_param_expr(2))->get_value().get_int());
3932
              OZ (get_subprogram_var(current_block_->get_namespace(), subprogram_id, var_idx, var));
3933
              CK (OB_NOT_NULL(var));
3934
              OX (expected_type = &(var->get_type()));
3935
            } else {
3936
              ObDataType data_type;
3937
              data_type.set_meta_type(into_expr->get_result_type());
3938
              data_type.set_accuracy(into_expr->get_accuracy());
3939
              expected_type_local.set_data_type(data_type);
3940
              expected_type = &expected_type_local;
3941
            }
3942
            if (OB_SUCC(ret)) {
3943
              if (lib::is_oracle_mode()) {
3944
                CK (OB_LIKELY(T_SP_DECL_DEFAULT == value_node->type_));
3945
                if (OB_SUCC(ret)) {
3946
                  need_expect_type = T_DEFAULT == value_node->children_[0]->type_ ? false : need_expect_type;
3947
                }
3948
                OZ (resolve_expr(value_node->children_[0], func, value_expr,
3949
                                 combine_line_and_col(value_node->children_[0]->stmt_loc_),
3950
                                 true, expected_type));
3951
                CK (OB_NOT_NULL(value_expr));
3952
                // a cursor type cann't assign to a ref cursor type, just as int cann't assign to int*
3953
                if (OB_SUCC(ret) && OB_NOT_NULL(expected_type)) {
3954
                  OZ (check_assign_type(*expected_type, value_expr));
3955
                }
3956
                if (OB_SUCC(ret)) {
3957
                  if (T_FUN_PL_COLLECTION_CONSTRUCT == value_expr->get_expr_type()
3958
                      && 0 == value_expr->get_param_count()) {
3959
                    stmt->add_value(PL_CONSTRUCT_COLLECTION);
3960
                  } else {
3961
                    stmt->add_value(func.get_expr_count() - 1);
3962
                  }
3963
                }
3964
                // 目标是QuestionMark, 需要设置目标的类型, 因为QuestionMark默认是无类型的, 在赋值时确定类型
3965
                if (OB_SUCC(ret) && is_question_mark_value(into_expr, &(current_block_->get_namespace()))) {
3966
                  if (value_expr->get_result_type().is_ext()) {
3967
                    const ObUserDefinedType *user_type = NULL;
3968
                    OZ (current_block_->get_namespace().get_pl_data_type_by_id(
3969
                      value_expr->get_result_type().get_udt_id(), user_type));
3970
                    OZ (set_question_mark_type(into_expr, &(current_block_->get_namespace()), user_type));
3971
                  } else {
3972
                    ObDataType data_type;
3973
                    ObPLDataType pl_type;
3974
                    OX (data_type.set_meta_type(value_expr->get_result_type()));
3975
                    OX (data_type.set_accuracy(value_expr->get_result_type().get_accuracy()));
3976
                    OX (pl_type.set_data_type(data_type));
3977
                    OX (set_question_mark_type(into_expr, &(current_block_->get_namespace()), &pl_type));
3978
                  }
3979
                }
3980
              } else {
3981
                OZ (resolve_expr(value_node, func, value_expr,
3982
                                 combine_line_and_col(value_node->stmt_loc_),
3983
                                 true, need_expect_type ? expected_type : NULL));
3984
                if (OB_SUCC(ret)
3985
                    && T_DEFAULT == value_node->type_
3986
                    && into_expr->get_expr_type() != T_OP_GET_SYS_VAR) {
3987
                  ret = OB_NOT_SUPPORTED;
3988
                  LOG_WARN("default value only used by system variables");
3989
                  LOG_USER_ERROR(OB_NOT_SUPPORTED, "default value not used by system variables");
3990
                }
3991
                OZ (stmt->add_value(func.get_expr_count() - 1));
3992
              }
3993
            }
3994
          }
3995
        }
3996
      }
3997
    }
3998
  }
3999
  return ret;
4000
}
4001

4002
int ObPLResolver::resolve_if(const ObStmtNodeTree *parse_tree, ObPLIfStmt *stmt, ObPLFunctionAST &func)
4003
{
4004
  int ret = OB_SUCCESS;
4005
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
4006
    ret = OB_INVALID_ARGUMENT;
4007
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(ret));
4008
  } else {
4009
    //解析expr then结构
4010
    ObRawExpr *expr = NULL;
4011
    ObPLStmtBlock *then_block = NULL;
4012
    ObPLDataType data_type(ObTinyIntType);
4013
    set_item_type(T_SP_IF);
4014
    if (OB_FAIL(resolve_then(
4015
        parse_tree, func, &data_type, expr, then_block, lib::is_mysql_mode()))) {
4016
      LOG_WARN("failed to resolve then", K(ret));
4017
    } else if (OB_FAIL(func.add_expr(expr))) {
4018
      LOG_WARN("failed to add expr", K(*expr), K(ret));
4019
    } else {
4020
      stmt->set_cond(func.get_expr_count() - 1);
4021
      stmt->set_then(then_block);
4022
    }
4023

4024
    //解析else子句
4025
    if (OB_SUCC(ret)) {
4026
      const ObStmtNodeTree *else_node = parse_tree->children_[2];
4027
      if (NULL == else_node) {
4028
        //do nothing
4029
      } else if (T_SP_ELSE != else_node->type_ || OB_ISNULL(else_node->children_[0])) {
4030
        ret = OB_ERR_UNEXPECTED;
4031
        LOG_WARN("Invalid else node type", K(else_node->type_), K(else_node->children_[0]), K(ret));
4032
      } else if (T_SP_PROC_STMT_LIST != else_node->children_[0]->type_) {
4033
        ret = OB_ERR_UNEXPECTED;
4034
        LOG_WARN("Invalid else node", K(else_node->children_[0]->type_), K(ret));
4035
      } else {
4036
        ObPLStmtBlock *else_block = NULL;
4037
        if (OB_FAIL(resolve_stmt_list(else_node->children_[0], else_block, func))) {
4038
          LOG_WARN("failed to resolve stmt list", K(else_node->children_[0]->type_), K(ret));
4039
        } else {
4040
          stmt->set_else(else_block);
4041
        }
4042
      }
4043
    }
4044
  }
4045
  return ret;
4046
}
4047

4048
int ObPLResolver::resolve_case(const ObStmtNodeTree *parse_tree, ObPLCaseStmt *stmt, ObPLFunctionAST &func)
4049
{
4050
  int ret = OB_SUCCESS;
4051

4052
  ObConstRawExpr *case_var = nullptr;
4053
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
4054
    ret = OB_INVALID_ARGUMENT;
4055
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(ret));
4056
  } else {
4057
    //解析expr
4058
    ObRawExpr *case_expr = NULL;
4059
    const ObStmtNodeTree *expr_node = parse_tree->children_[0];
4060
    set_item_type(T_SP_CASE);
4061
    ObPLStmtBlock *current_block = current_block_;
4062
    if (OB_FAIL(make_block(func, current_block, current_block_))) {
4063
      LOG_WARN("failed to make block", K(ret));
4064
    } else if (NULL == expr_node) {
4065
      //没有case表达式
4066
    } else if (OB_FAIL(resolve_expr(expr_node,
4067
                                    func,
4068
                                    case_expr,
4069
                                    combine_line_and_col(expr_node->stmt_loc_)))) {
4070
      LOG_WARN("failed to resolve expr", K(expr_node), K(ret));
4071
    } else if (OB_FAIL(current_block_->get_namespace().add_symbol(
4072
                   ObString(""), // anonymous variable for holding case expr value
4073
                   case_expr->get_data_type()))) {
4074
      LOG_WARN("failed to add CASE expr var to symbol table");
4075
    } else {
4076
      stmt->set_case_expr(func.get_expr_count() - 1);
4077
      stmt->set_case_var(func.get_symbol_table().get_count() - 1);
4078
      OZ(expr_factory_.create_raw_expr(T_QUESTIONMARK, case_var));
4079
      CK(OB_NOT_NULL(case_var));
4080
      if (OB_SUCC(ret)) {
4081
        ObObjParam val;
4082
        val.set_unknown(stmt->get_case_var());
4083
        val.set_param_meta();
4084
        case_var->set_value(val);
4085
        case_var->set_result_type(case_expr->get_result_type());
4086
        OZ (case_var->extract_info());
4087
      }
4088
    }
4089

4090
    //解析when子句
4091
    const ObStmtNodeTree *when_list = parse_tree->children_[1];
4092
    OZ (resolve_when(when_list, case_var, stmt, func));
4093

4094
    //解析else子句
4095
    if (OB_SUCC(ret)) {
4096
      const ObStmtNodeTree *else_node = parse_tree->children_[2];
4097
      ObPLStmtBlock *else_block = NULL;
4098
      if (NULL == else_node) {
4099
        /*
4100
         * Mysql在运行态发现没有when子句能够匹配，并且没有else子句，会报错。所以这里为else分支生成一个Signal语句。
4101
         * If no when_value or search_condition matches the value tested and the CASE statement contains no ELSE clause,
4102
         * a Case not found for CASE statement error results.
4103
         * */
4104
        if (OB_FAIL(make_block(func, current_block_, else_block))) {
4105
          LOG_WARN("failed to make block", K(ret));
4106
        } else {
4107
          ObPLStmt *stmt = NULL;
4108
          ObPLSignalStmt *signal_stmt = NULL;
4109
          if (OB_FAIL(stmt_factory_.allocate(PL_SIGNAL, else_block, stmt))) {
4110
            LOG_WARN("failed to alloc stmt", K(ret));
4111
          } else if (OB_ISNULL(signal_stmt = static_cast<ObPLSignalStmt*>(stmt))) {
4112
            LOG_WARN("failed to cast stmt", K(ret));
4113
          } else {
4114
            signal_stmt->set_cond_type(ERROR_CODE);
4115
            signal_stmt->set_sql_state("20000");
4116
            signal_stmt->set_str_len(5);
4117
            if (lib::is_oracle_mode()) {
4118
              signal_stmt->set_error_code(OB_ER_SP_CASE_NOT_FOUND); // ORACLE模式使用OB的错误码
4119
            } else {
4120
              signal_stmt->set_error_code(ER_SP_CASE_NOT_FOUND); // MySQL模式使用Mysql错误码
4121
            }
4122
            signal_stmt->set_ob_error_code(OB_ER_SP_CASE_NOT_FOUND);
4123
            if (OB_FAIL(else_block->add_stmt(signal_stmt))) {
4124
              LOG_WARN("failed to add stmt", K(stmt), K(ret));
4125
            }
4126
          }
4127
        }
4128
      } else {
4129
        if (T_SP_ELSE != else_node->type_ || OB_ISNULL(else_node->children_[0])) {
4130
          ret = OB_ERR_UNEXPECTED;
4131
          LOG_WARN("Invalid else node type", K(else_node->type_), K(else_node->children_[0]), K(ret));
4132
        } else if (T_SP_PROC_STMT_LIST != else_node->children_[0]->type_) {
4133
          ret = OB_ERR_UNEXPECTED;
4134
          LOG_WARN("Invalid else node", K(else_node->children_[0]->type_), K(ret));
4135
        } else {
4136
          if (OB_FAIL(resolve_stmt_list(else_node->children_[0], else_block, func))) {
4137
            LOG_WARN("failed to resolve stmt list", K(else_node->children_[0]->type_), K(ret));
4138
          }
4139
        }
4140
      }
4141

4142
      if (OB_SUCC(ret)) {
4143
        stmt->set_else_clause(else_block);
4144
      }
4145
    }
4146

4147
    //恢复current_block_
4148
    if (OB_SUCC(ret)) {
4149
      set_current(*current_block);
4150
    }
4151
  }
4152
  return ret;
4153
}
4154

4155
int ObPLResolver::resolve_when(const ObStmtNodeTree *parse_tree, ObRawExpr *case_expr_var, ObPLCaseStmt *stmt, ObPLFunctionAST &func)
4156
{
4157
  int ret = OB_SUCCESS;
4158
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
4159
    ret = OB_ERR_UNEXPECTED;
4160
    LOG_WARN("parse_tree of when list is NULL", K(parse_tree), K(stmt), K(ret));
4161
  } else if (T_WHEN_LIST != parse_tree->type_) {
4162
    ret = OB_ERR_UNEXPECTED;
4163
    LOG_WARN("Invalid when node type", K(parse_tree->type_), K(ret));
4164
  } else if (0 >= parse_tree->num_child_) {  // one when clause at least
4165
    ret = OB_ERR_UNEXPECTED;
4166
    LOG_WARN("unexpected when list number", K(ret));
4167
  } else {
4168
    for (int64_t i = 0; OB_SUCC(ret) && i < parse_tree->num_child_; ++i) {
4169
      ObRawExpr *expr = nullptr;
4170
      ObPLStmtBlock *body = nullptr;
4171
      ObPLDataType data_type(ObTinyIntType);
4172
      bool is_bool_stmt = false;
4173
      if (!case_expr_var && lib::is_mysql_mode()) {
4174
        is_bool_stmt = true;
4175
      }
4176
      set_item_type(T_SP_WHEN);
4177
      if (OB_FAIL(make_block(func, current_block_, body))) {
4178
        LOG_WARN("failed to make block");
4179
      } else if (OB_FAIL(resolve_then(parse_tree->children_[i],
4180
                                      func,
4181
                                      case_expr_var ? nullptr : &data_type,
4182
                                      expr,
4183
                                      body,
4184
                                      is_bool_stmt))) {
4185
        LOG_WARN("failed to resolve then", K(ret));
4186
      }
4187

4188
      if (OB_SUCC(ret) && case_expr_var) {
4189
        ObRawExpr *cmp_expr = nullptr;
4190

4191
        OZ (ObRawExprUtils::create_equal_expr(expr_factory_,
4192
                                             &resolve_ctx_.session_info_,
4193
                                             case_expr_var,
4194
                                             expr,
4195
                                             cmp_expr));
4196
        OX (expr = cmp_expr);
4197
      }
4198

4199
      OZ (func.add_expr(expr));
4200
      OZ (expr->formalize(&resolve_ctx_.session_info_));
4201
      OZ (stmt->add_when_clause(func.get_expr_count() - 1, body));
4202
    }
4203
  }
4204
  return ret;
4205
}
4206

4207
int ObPLResolver::resolve_then(const ObStmtNodeTree *parse_tree,
4208
                               ObPLFunctionAST &func,
4209
                               ObPLDataType *data_type,
4210
                               ObRawExpr *&expr,
4211
                               ObPLStmtBlock *&then_block,
4212
                               bool is_add_bool_expr)
4213
{
4214
  int ret = OB_SUCCESS;
4215
  if (OB_ISNULL(parse_tree)) {
4216
    ret = OB_INVALID_ARGUMENT;
4217
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(ret));
4218
  } else {
4219
    //解析expr
4220
    const ObStmtNodeTree *expr_node = parse_tree->children_[0];
4221
    if (NULL == expr_node) {
4222
      ret = OB_ERR_UNEXPECTED;
4223
      LOG_WARN("expr node is NULL", K(expr_node), K(parse_tree->children_), K(ret));
4224
    } else if (OB_FAIL(resolve_expr(expr_node, func, expr,
4225
                                    combine_line_and_col(expr_node->stmt_loc_),
4226
                                    false, data_type, false, is_add_bool_expr))) {
4227
      LOG_WARN("failed to resolve expr", K(expr_node), K(ret));
4228
    } else { /*do nothing*/ }
4229

4230
    //解析then子句
4231
    if (OB_SUCC(ret)) {
4232
      reset_item_type();
4233
      const ObStmtNodeTree *then_node = parse_tree->children_[1];
4234
      if (NULL == then_node) {
4235
        ret = OB_ERR_UNEXPECTED;
4236
        LOG_WARN("then node is NULL", K(then_node), K(parse_tree->children_), K(ret));
4237
      } else if (T_SP_PROC_STMT_LIST != then_node->type_) {
4238
        ret = OB_ERR_UNEXPECTED;
4239
        LOG_WARN("Invalid then node type", K(then_node->type_), K(ret));
4240
      } else if (OB_FAIL(resolve_stmt_list(then_node, then_block, func))) {
4241
        LOG_WARN("failed to resolve stmt list", K(then_node->type_), K(ret));
4242
      } else { /*do nothing*/ }
4243
    }
4244
  }
4245
  return ret;
4246
}
4247

4248
int ObPLResolver::resolve_loop_control(const ObStmtNodeTree *parse_tree, ObPLLoopControl *stmt, bool is_iterate_label, ObPLFunctionAST &func)
4249
{
4250
  int ret = OB_SUCCESS;
4251
  UNUSED(func);
4252
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
4253
    ret = OB_INVALID_ARGUMENT;
4254
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
4255
  } else if (NULL != parse_tree->children_[0]) {
4256
    //解析label
4257
    ObString name;
4258
    int64_t label = OB_INVALID_INDEX;
4259
    const ObStmtNodeTree *label_node = parse_tree->children_[0];
4260
    if (OB_FAIL(resolve_ident(label_node, name))) {
4261
      LOG_WARN("failed to resolve ident", K(label_node), K(ret));
4262
    } else if (OB_FAIL(resolve_label(name, current_block_->get_namespace(), label, is_iterate_label))) {
4263
      if (OB_ERR_SP_LILABEL_MISMATCH == ret && lib::is_oracle_mode()) {
4264
        ret = OB_ERR_NEED_A_LABEL;
4265
        LOG_USER_ERROR(OB_ERR_NEED_A_LABEL, name.length(), name.ptr());
4266
      } else {
4267
        LOG_WARN("failed to resolve label", K(name), K(ret));
4268
      }
4269
    } else if (OB_INVALID_INDEX == label) {
4270
      ret = OB_ERR_UNEXPECTED;
4271
      LOG_WARN("can not resolve label", K(name), K(label), K(ret));
4272
    } else {
4273
      stmt->set_next_label(name);
4274
    }
4275
  } else if (!lib::is_oracle_mode()) {
4276
    ret = OB_ERR_UNEXPECTED;
4277
    LOG_WARN("must have label name in iterate stme", K(resolve_ctx_.session_info_.get_compatibility_mode()), K(ret));
4278
  } else { /*do nothing*/ }
4279

4280
  if (OB_SUCC(ret)) {
4281
    //解析condition
4282
    const ObStmtNodeTree *cond_node = parse_tree->children_[1];
4283
    if (NULL != cond_node) {
4284
      if (lib::is_oracle_mode()) {
4285
        ObRawExpr *expr = NULL;
4286
        ObPLDataType data_type(ObTinyIntType);
4287
        if (OB_FAIL(resolve_expr(cond_node, func, expr, combine_line_and_col(cond_node->stmt_loc_),
4288
             true, &data_type, false, lib::is_mysql_mode()))) {
4289
          LOG_WARN("failed to resolve then", K(ret));
4290
        } else {
4291
          stmt->set_cond(func.get_expr_count() - 1);
4292
        }
4293
      } else {
4294
        ret = OB_ERR_UNEXPECTED;
4295
        LOG_WARN("condition loop is not support in mysql mode", K(ret));
4296
      }
4297
    }
4298
  }
4299
  return ret;
4300
}
4301

4302
int ObPLResolver::resolve_iterate(const ObStmtNodeTree *parse_tree, ObPLIterateStmt *stmt, ObPLFunctionAST &func)
4303
{
4304
  return resolve_loop_control(parse_tree, stmt, true, func);
4305
}
4306

4307
int ObPLResolver::resolve_leave(const ObStmtNodeTree *parse_tree, ObPLLeaveStmt *stmt, ObPLFunctionAST &func)
4308
{
4309
  return resolve_loop_control(parse_tree, stmt, false, func);
4310
}
4311

4312
int ObPLResolver::resolve_while(const ObStmtNodeTree *parse_tree, ObPLWhileStmt *stmt, ObPLFunctionAST &func)
4313
{
4314
  int ret = OB_SUCCESS;
4315
  if (OB_ISNULL(parse_tree)) {
4316
    ret = OB_INVALID_ARGUMENT;
4317
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(ret));
4318
  } else {
4319
    const ObStmtNodeTree *expr_node = parse_tree->children_[0];
4320
    const ObStmtNodeTree *body_node = parse_tree->children_[1];
4321
    if (OB_FAIL(resolve_cond_loop(expr_node, body_node, stmt, func))) {
4322
      LOG_WARN("failed to resolve while", K(parse_tree), K(stmt), K(ret));
4323
    }
4324
  }
4325
  return ret;
4326
}
4327

4328
int ObPLResolver::resolve_for_loop(const ObStmtNodeTree *parse_tree, ObPLForLoopStmt *stmt, ObPLFunctionAST &func)
4329
{
4330
  int ret = OB_SUCCESS;
4331
  CK(OB_NOT_NULL(parse_tree),
4332
     OB_NOT_NULL(stmt),
4333
     T_SP_FOR_LOOP == parse_tree->type_,
4334
     5 == parse_tree->num_child_,
4335
     OB_NOT_NULL(parse_tree->children_[0]),
4336
     OB_NOT_NULL(parse_tree->children_[1]),
4337
     OB_NOT_NULL(parse_tree->children_[2]));
4338
  if (OB_SUCC(ret)) {
4339
    bool reverse = static_cast<bool>(parse_tree->value_);
4340
    const ObStmtNodeTree *index_node = parse_tree->children_[0];
4341
    const ObStmtNodeTree *lower_node = parse_tree->children_[1];
4342
    const ObStmtNodeTree *upper_node = parse_tree->children_[2];
4343
    const ObStmtNodeTree *body_node  = parse_tree->children_[3];
4344
    ObPLDataType data_type;
4345
    ObPLStmtBlock *body_block = NULL;
4346
    // 解析reverse
4347
    stmt->set_reverse(reverse);
4348
    // 解析index
4349
    if (OB_SUCC(ret)) {
4350
      ObString index_name;
4351
      if (OB_FAIL(build_pl_integer_type(PL_PLS_INTEGER, data_type))) {
4352
        LOG_WARN("failed to build pl integer type", K(ret));
4353
      } else if (OB_FAIL(make_block(func, current_block_, body_block, true))) {
4354
        LOG_WARN("failed to make blocl", K(current_block_), K(ret));
4355
      } else if (OB_ISNULL(body_block)) {
4356
        ret = OB_ERR_UNEXPECTED;
4357
        LOG_WARN("failed to allocate block", K(body_block), K(ret));
4358
      } else if (OB_FAIL(resolve_ident(index_node, index_name))) {
4359
        LOG_WARN("failed to resolve ident", K(index_node), K(ret));
4360
      } else if (OB_FAIL(body_block->get_namespace().add_symbol(index_name,
4361
                                                                data_type,
4362
                                                                NULL,
4363
                                                                true))) { /*index 只读，不可再循环体内赋值*/
4364
        LOG_WARN("fail to add for loop index variable to symbol", K(ret));
4365
      } else {
4366
        stmt->set_ident(func.get_symbol_table().get_count() - 1);
4367
      }
4368
    }
4369
    // 解析lower bound expr
4370
    if (OB_SUCC(ret)) {
4371
      ObRawExpr *lower_expr = NULL;
4372
      if (OB_FAIL(resolve_expr(lower_node, static_cast<ObPLCompileUnitAST&>(func), lower_expr,
4373
                               combine_line_and_col(lower_node->stmt_loc_), true, &data_type))) {
4374
        LOG_WARN("failed to resolve expr", K(lower_node), K(ret));
4375
      } else {
4376
        stmt->set_lower(func.get_expr_count() - 1);
4377
      }
4378
    }
4379
    // 解析upper bound expr
4380
    if (OB_SUCC(ret)) {
4381
      ObRawExpr *upper_expr = NULL;
4382
      if (OB_FAIL(resolve_expr(upper_node, static_cast<ObPLCompileUnitAST&>(func), upper_expr,
4383
                               combine_line_and_col(upper_node->stmt_loc_), true, &data_type))) {
4384
        LOG_WARN("failed to resolve expr", K(upper_node), K(ret));
4385
      } else {
4386
        stmt->set_upper(func.get_expr_count() - 1);
4387
      }
4388
    }
4389
    // 解析body
4390
    if (OB_SUCC(ret)) {
4391
      if (OB_FAIL(resolve_stmt_list(body_node, body_block, func))) {
4392
        LOG_WARN("failed to resolve stmt list", K(body_node->type_), K(ret));
4393
      } else {
4394
        stmt->set_body(body_block);
4395
      }
4396
    }
4397
  }
4398
  return ret;
4399
}
4400

4401
int ObPLResolver::resolve_cursor_for_loop(
4402
  const ObStmtNodeTree *parse_tree, ObPLCursorForLoopStmt *stmt, ObPLFunctionAST &func)
4403
{
4404
  int ret = OB_SUCCESS;
4405
  CK (OB_NOT_NULL(parse_tree));
4406
  CK (OB_NOT_NULL(stmt));
4407
  CK (T_SP_CURSOR_FOR_LOOP == parse_tree->type_);
4408
  CK (4 == parse_tree->num_child_);
4409
  CK (OB_NOT_NULL(parse_tree->children_[0]));
4410
  CK (OB_NOT_NULL(parse_tree->children_[1]));
4411
  if (OB_SUCC(ret)) {
4412
    question_mark_cnt_ = parse_tree->value_;
4413
    const ObStmtNodeTree* index_node = parse_tree->children_[0];
4414
    const ObStmtNodeTree* cursor_node = parse_tree->children_[1];
4415
    const ObStmtNodeTree* body_node = parse_tree->children_[2];
4416
    ObString index_name;
4417
    ObPLStmtBlock *body_block = NULL;
4418
    // 创建body block
4419
    if (OB_SUCC(ret)) {
4420
      if (OB_FAIL(make_block(func, current_block_, body_block, true))) {
4421
        LOG_WARN("failed to make block", K(ret));
4422
      } else if (OB_ISNULL(body_block)) {
4423
        ret = OB_ERR_UNEXPECTED;
4424
        LOG_WARN("failed to allocate body block", K(ret));
4425
      }
4426
    }
4427
    // 解析cursor
4428
    if (OB_SUCC(ret)) {
4429
      int64_t cursor_index = OB_INVALID_ID;
4430
      if (T_OBJ_ACCESS_REF == cursor_node->type_) {
4431
        CK (cursor_node->num_child_ >= 1);
4432
        CK (OB_NOT_NULL(cursor_node->children_[0]));
4433
        OX (cursor_node = T_FUN_SYS == cursor_node->children_[0]->type_ ?
4434
          cursor_node->children_[0] : cursor_node);
4435

4436
        // 解析Cursor
4437
        OZ (resolve_cursor(
4438
          (T_FUN_SYS == cursor_node->type_) ? cursor_node->children_[0] : cursor_node,
4439
          current_block_->get_namespace(), cursor_index, func));
4440
        OX (stmt->set_cursor_index(cursor_index));
4441

4442
        //解析实参
4443
        if (OB_SUCC(ret)) {
4444
          const ObStmtNodeTree *param_node = NULL;
4445
          if (T_FUN_SYS == cursor_node->type_ && cursor_node->num_child_ > 1) {
4446
            param_node = cursor_node->children_[1];
4447
          } else if (T_OBJ_ACCESS_REF == cursor_node->type_
4448
                     && cursor_node->children_[1] != NULL
4449
                     && T_FUN_SYS == cursor_node->children_[1]->children_[0]->type_
4450
                     && cursor_node->children_[1]->children_[0]->num_child_ > 1) {
4451
            param_node = cursor_node->children_[1]->children_[0]->children_[1];
4452
          }
4453
          OZ (resolve_cursor_actual_params(param_node, stmt, func));
4454
        }
4455
        if (OB_SUCC(ret)) {
4456
          const ObPLVar *var = NULL;
4457
          const ObPLCursor *cursor = stmt->get_cursor();
4458
          if (OB_FAIL(stmt->get_var(var))) {
4459
            LOG_WARN("failed to get var", K(ret));
4460
          } else if (OB_ISNULL(cursor)) {
4461
            ret = OB_ERR_UNEXPECTED;
4462
            LOG_WARN("value is NULL", K(ret));
4463
          } else if (ObPLCursor::DEFINED != cursor->get_state()) {
4464
            if (OB_NOT_NULL(var) && var->get_pl_data_type().is_ref_cursor_type()) {
4465
              ret = OB_ERR_UNDEFINED;
4466
              LOG_WARN("ref cursor not defined", KPC(var), K(ret));
4467
              LOG_USER_ERROR(OB_ERR_UNDEFINED, var->get_name().ptr());
4468
            } else {
4469
              ret = OB_ERR_TYPE_DECL_MALFORMED;
4470
              LOG_WARN("cursor not defined", KPC(var), K(ret));
4471
            }
4472
          }
4473
        }
4474
      } else if (T_SQL_STMT == cursor_node->type_) {
4475
        ObPLStmtBlock *parent = current_block_;
4476
        set_current(*body_block);
4477
        ObString cursor_name;
4478
        ObPLDataType dummy_return_type;
4479
        ObArray<int64_t> dummy_formal_params;
4480
        if (OB_FAIL(resolve_cursor_def(cursor_name, cursor_node,  body_block->get_namespace(),
4481
                                   dummy_return_type, dummy_formal_params, func, cursor_index))) {
4482
          LOG_WARN("failed to resolve cursor comm", K(ret), K(cursor_name), K(cursor_node->type_));
4483
        } else {
4484
          stmt->set_cursor_index(cursor_index);
4485
          stmt->set_need_declare(true);
4486
          set_current(*parent);
4487
        }
4488
      } else {
4489
        ret = OB_INVALID_ARGUMENT;
4490
        LOG_WARN("name cursro node is invalid", K(ret), K(cursor_node->type_));
4491
      }
4492
      if (OB_SUCC(ret)) {
4493
        ObPLCursor *cursor = current_block_->get_cursor(cursor_index);
4494
        if (OB_NOT_NULL(cursor) && cursor->is_dup_column()) {
4495
          ret = OB_ERR_DUP_NAME_IN_CURSOR;
4496
          LOG_WARN("alias required in SELECT list of cursor to avoid duplicate column names", K(ret), K(cursor_index));
4497
        }
4498
      }
4499
    }
4500
    // 解析index
4501
    if (OB_SUCC(ret)) {
4502
      const ObUserDefinedType *user_type = NULL;
4503
      if (OB_FAIL(resolve_ident(index_node, index_name))) {
4504
        LOG_WARN("failed to resolve ident", K(ret));
4505
      } else if (OB_FAIL(body_block->get_namespace().add_symbol(index_name,
4506
                                                                stmt->get_cursor()->get_cursor_type(),
4507
                                                                NULL,
4508
                                                                false))) { /*与ForLoop不同，CursorForLoop的index可以在循环体内赋值*/
4509
        LOG_WARN("fail to add for loop index variable to symbol", K(ret));
4510
      } else if (OB_FAIL(body_block->get_namespace().get_pl_data_type_by_id(
4511
                  stmt->get_cursor()->get_cursor_type().get_user_type_id(), user_type))) {
4512
        LOG_WARN("fail to get user type", K(ret));
4513
      } else if (OB_ISNULL(user_type)) {
4514
        ret = OB_ERR_UNEXPECTED;
4515
        LOG_WARN("user type is null", K(ret));
4516
      } else {
4517
        if (OB_SUCC(ret)) {
4518
          stmt->set_user_type(user_type);
4519
          stmt->set_index_index(func.get_symbol_table().get_count() - 1);
4520
        }
4521
      }
4522
    }
4523
    // 将index作为fetch into变量
4524
    if (OB_SUCC(ret)) {
4525
      ObRawExpr *expr = NULL;
4526
      if (OB_FAIL(ObPLResolver::resolve_local_var(index_name,
4527
                                                  body_block->get_namespace(),
4528
                                                  expr_factory_,
4529
                                                  &resolve_ctx_.session_info_,
4530
                                                  &resolve_ctx_.schema_guard_,
4531
                                                  expr))) {
4532
        LOG_WARN("failed to resolve_local_var", K(ret));
4533
      } else if (OB_FAIL(func.add_expr(expr))) {
4534
        LOG_WARN("failed ot add expr", K(ret));
4535
      } else if (OB_FAIL(stmt->add_into(func.get_expr_count() - 1, current_block_->get_namespace(), *expr))) {
4536
        LOG_WARN("failed to add into", K(ret));
4537
      } else if (!expr->is_obj_access_expr()) { // cursor 的返回值是一个record变量, 因此这里一定是个obj_access_expr
4538
        ret = OB_ERR_UNEXPECTED;
4539
        LOG_WARN("cursor for loop into expr not access expr", K(ret));
4540
      } else if (OB_FAIL(func.add_obj_access_expr(expr))) {
4541
          LOG_WARN("push_back error", K(ret));
4542
      }
4543
    }
4544
    // 解析body
4545
    if (OB_SUCC(ret)) {
4546
      // 这儿做了一个block，这样一个for loop cursor会有两个block， 一个是定义的，一个是body
4547
      // 这么做的原因是在code gen的时候，在block结尾出会close cursor，如果连个是连在一起，那么
4548
      // 第一次for 循环结束后就会close cursor，导致后续的fetch，cursor都是close的。
4549
      // 提取之后，cursor就定义在前一个block中，在循环体block不会去做close的动作。
4550
      ObPLStmtBlock *body_body_block = NULL;
4551
      if (OB_FAIL(make_block(func, body_block, body_body_block, true))) {
4552
        LOG_WARN("failed to make block", K(ret));
4553
      } else if (OB_ISNULL(body_body_block)) {
4554
        ret = OB_ERR_UNEXPECTED;
4555
        LOG_WARN("failed to allocate body block", K(ret));
4556
      } else if (OB_FAIL(resolve_stmt_list(body_node, body_body_block, func))) {
4557
        LOG_WARN("failed to resolve stmt list", K(body_node->type_), K(ret));
4558
      } else {
4559
        stmt->set_body(body_body_block);
4560
      }
4561
    }
4562
  }
4563
  return ret;
4564
}
4565

4566
int ObPLResolver::check_use_idx_illegal(ObRawExpr* expr, int64_t idx)
4567
{
4568
  int ret = OB_SUCCESS;
4569
  if (OB_NOT_NULL(expr)) {
4570
    if (T_QUESTIONMARK == expr->get_expr_type()) {
4571
      ObConstRawExpr *const_expr = static_cast<ObConstRawExpr*>(expr);
4572
      if (idx == const_expr->get_value().get_unknown()) {
4573
        ret = OB_ERR_FORALL_ITER_NOT_ALLOWED;
4574
        LOG_WARN("PLS-00430: FORALL iteration variable INDX is not allowed in this context", K(ret));
4575
      }
4576
    } else {
4577
      for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
4578
        OZ (check_use_idx_illegal(expr->get_param_expr(i), idx));
4579
      }
4580
    }
4581
  }
4582
  return ret;
4583
}
4584

4585
int ObPLResolver::check_raw_expr_in_forall(ObRawExpr* expr, int64_t idx, bool &need_modify, bool &can_array_binding)
4586
{
4587
  int ret = OB_SUCCESS;
4588
  CK (OB_NOT_NULL(expr));
4589
  if (OB_SUCC(ret)) {
4590
    need_modify = false;
4591
    if (expr->is_obj_access_expr()) {
4592
      ObObjAccessRawExpr *obj_access_expr = static_cast<ObObjAccessRawExpr*>(expr);
4593
      int64_t collection_index = 0;
4594
      for (int64_t i = 0; i < obj_access_expr->get_access_idxs().count(); ++i) {
4595
        if (obj_access_expr->get_access_idxs().at(i).elem_type_.is_collection_type()) {
4596
          collection_index = i;
4597
          break;
4598
        }
4599
      }
4600
      if (obj_access_expr->get_access_idxs().count() > 1
4601
          && obj_access_expr->get_access_idxs().at(collection_index).elem_type_.is_collection_type()) {
4602
        if (obj_access_expr->get_access_idxs().at(collection_index + 1).is_local()) {
4603
          int64_t var_idx = obj_access_expr->get_access_idxs().at(collection_index + 1).var_index_;
4604
          if (var_idx < 0 || var_idx >= obj_access_expr->get_var_indexs().count()) {
4605
            ret = OB_ERR_UNEXPECTED;
4606
            LOG_WARN("var index is invalid", K(var_idx), K(obj_access_expr->get_var_indexs()), K(ret));
4607
          } else if (obj_access_expr->get_var_indexs().at(var_idx) == idx) {
4608
            need_modify = true;
4609
            if (obj_access_expr->get_var_indexs().count() != 2
4610
                || !obj_access_expr->get_access_idxs().at(collection_index + 1).elem_type_.is_obj_type()) {
4611
              can_array_binding = false;
4612
            } else if (2 == obj_access_expr->get_access_idxs().count() - collection_index) {
4613
              can_array_binding = (0 == collection_index);
4614
            } else if (obj_access_expr->get_access_idxs().at(collection_index + 2).is_const()) {
4615
              can_array_binding = false;
4616
            } else {
4617
              ret = OB_ERR_BULK_IN_BIND;
4618
              LOG_WARN("PLS-00674: references to fields of BULK In-BIND table of records or objects must have the form A(I).F",
4619
                       K(ret), K(obj_access_expr));
4620
            }
4621
          }
4622
        } else if (obj_access_expr->get_access_idxs().at(1).is_expr()) {
4623
          CK (OB_NOT_NULL(obj_access_expr->get_access_idxs().at(1).get_sysfunc_));
4624
          if (OB_FAIL(ret)) {
4625
          } else if (T_FUN_PL_ASSOCIATIVE_INDEX == obj_access_expr->get_access_idxs().at(1).get_sysfunc_->get_expr_type()) {
4626
            ObPLAssocIndexRawExpr *result_expr = static_cast<ObPLAssocIndexRawExpr *>(
4627
              obj_access_expr->get_access_idxs().at(1).get_sysfunc_);
4628
            ObConstRawExpr *const_expr = NULL;
4629
            CK (OB_NOT_NULL(result_expr));
4630
            CK (OB_NOT_NULL(result_expr->get_param_expr(1)));
4631
            if (OB_SUCC(ret) && result_expr->get_param_expr(1)->is_const_raw_expr()) {
4632
              CK (OB_NOT_NULL(const_expr = static_cast<ObConstRawExpr*>(result_expr->get_param_expr(1))));
4633
            }
4634
            if (OB_SUCC(ret) && OB_NOT_NULL(const_expr)) {
4635
              const ObObj &const_obj = const_expr->get_value();
4636
              if (const_obj.is_unknown() && (idx == const_obj.get_unknown())) {
4637
                need_modify = true;
4638
                can_array_binding = false;
4639
              }
4640
            }
4641
          } else {
4642
            OZ (check_use_idx_illegal(obj_access_expr->get_access_idxs().at(1).get_sysfunc_, idx));
4643
          }
4644
        } else if (obj_access_expr->get_access_idxs().at(1).is_const() ||
4645
                   obj_access_expr->get_access_idxs().at(1).is_pkg()) {
4646
          // do nothing ...
4647
        } else {
4648
          ret = OB_NOT_SUPPORTED;
4649
          LOG_WARN("not supported yet", K(ret), KPC(obj_access_expr));
4650
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "non-urowid type");
4651
        }
4652
      } else {
4653
        can_array_binding = false;
4654
      }
4655
    } else if (T_QUESTIONMARK == expr->get_expr_type()) {
4656
      ObConstRawExpr *const_expr = static_cast<ObConstRawExpr*>(expr);
4657
      if (idx == const_expr->get_value().get_unknown()) {
4658
        ret = OB_ERR_FORALL_ITER_NOT_ALLOWED;
4659
        LOG_WARN("PLS-00430: FORALL iteration variable INDX is not allowed in this context", K(ret));
4660
      }
4661
      //这里控制包含非数组类型变量的forall语句直接以forloop实现, 避免forall先回退, 再forloop执行
4662
      can_array_binding = true;
4663
    } else {
4664
      bool inner_modify = false;
4665
      bool inner_can_array_binding = true;
4666
      for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
4667
        OZ (check_raw_expr_in_forall(expr->get_param_expr(i), idx, inner_modify, inner_can_array_binding));
4668
        if (inner_modify) {
4669
          ret = OB_NOT_SUPPORTED;
4670
          LOG_WARN("not supported yet", K(ret), K(expr));
4671
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "expression batch execution in forall statement");
4672
        }
4673
      }
4674
    }
4675
  }
4676
  return ret;
4677
}
4678

4679
int ObPLResolver::modify_raw_expr_in_forall(ObPLForAllStmt &stmt,
4680
                                            ObPLFunctionAST &func,
4681
                                            ObPLSqlStmt &sql_stmt,
4682
                                            ObIArray<int64_t>& modify_exprs)
4683
{
4684
  int ret = OB_SUCCESS;
4685
  // only allow x(idx); y(x(idx)),y(abs(x(idx))),y(x(idx) + 1) is invalid
4686
  // in check_raw_expr_in_forall y(x(idx)) is valid, so here we check again
4687
  for (int64_t i = 0; OB_SUCC(ret) && i < modify_exprs.count(); ++i) {
4688
    ObRawExpr* expr = func.get_expr(sql_stmt.get_params().at(modify_exprs.at(i)));
4689
    ObObjAccessRawExpr *obj_access_expr = NULL;
4690
    CK (OB_NOT_NULL(expr));
4691
    CK (expr->is_obj_access_expr());
4692
    CK (OB_NOT_NULL(obj_access_expr = static_cast<ObObjAccessRawExpr*>(expr)));
4693
    CK (2 == obj_access_expr->get_access_idxs().count());
4694
    CK (2 == obj_access_expr->get_var_indexs().count());
4695
    CK (obj_access_expr->get_access_idxs().at(0).elem_type_.is_collection_type());
4696
    CK (1 == obj_access_expr->get_access_idxs().at(1).var_index_);
4697
    OZ (modify_raw_expr_in_forall(stmt, func, sql_stmt, modify_exprs.at(i),
4698
          obj_access_expr->get_var_indexs().at(0)));
4699
  }
4700
  return ret;
4701
}
4702

4703
int ObPLResolver::modify_raw_expr_in_forall(ObPLForAllStmt &stmt,
4704
                                            ObPLFunctionAST &func,
4705
                                            ObPLSqlStmt &sql_stmt,
4706
                                            int64_t modify_expr_id,
4707
                                            int64_t table_idx)
4708
{
4709
  int ret = OB_SUCCESS;
4710
  SET_LOG_CHECK_MODE();
4711
  hash::ObHashMap<int64_t, int64_t> &tab_to_subtab = stmt.get_tab_to_subtab_map();
4712
  int64_t sub_table_idx = OB_INVALID_INDEX;
4713
  if (OB_FAIL(tab_to_subtab.get_refactored(table_idx, sub_table_idx))) {
4714
    if (OB_HASH_NOT_EXIST != ret) {
4715
      LOG_WARN("failed to get refactored in hash map", K(ret), K(table_idx));
4716
    } else {
4717
      const ObPLVar *table_var = func.get_symbol_table().get_symbol(table_idx);
4718
      ret = OB_SUCCESS;
4719
      CK (OB_NOT_NULL(table_var));
4720
      CK (OB_NOT_NULL(stmt.get_body()));
4721
      ObPLBlockNS &ns = const_cast<ObPLBlockNS&>(stmt.get_body()->get_namespace());
4722
      OZ (ns.add_symbol(ObString(""), table_var->get_type(), NULL, true));
4723
      if (OB_SUCC(ret)) {
4724
        sub_table_idx = func.get_symbol_table().get_count() - 1;
4725
        OZ (tab_to_subtab.set_refactored(table_idx, sub_table_idx));
4726
      }
4727
    }
4728
  }
4729
  if (OB_SUCC(ret)) {
4730
    ObConstRawExpr* expr = NULL;
4731
    ObObjParam val;
4732
    ObExprResType res_type;
4733
    OZ (expr_factory_.create_raw_expr(T_QUESTIONMARK, expr));
4734
    CK (OB_NOT_NULL(expr));
4735
    if (OB_SUCC(ret)) {
4736
      val.set_unknown(sub_table_idx);
4737
      val.set_param_meta();
4738
      expr->set_value(val);
4739
      res_type.set_ext();
4740
      expr->set_result_type(res_type);
4741
      OZ (expr->extract_info());
4742
    }
4743
    if (OB_SUCC(ret)) {
4744
      func.add_expr(expr);
4745
      sql_stmt.get_array_binding_params().at(modify_expr_id) = func.get_expr_count() - 1;
4746
    }
4747
  }
4748
  CANCLE_LOG_CHECK_MODE();
4749
  return ret;
4750
}
4751

4752
int ObPLResolver::check_forall_sql_and_modify_params(ObPLForAllStmt &stmt, ObPLFunctionAST &func)
4753
{
4754
  /*
4755
   * dml_statement
4756
   * A static or dynamic INSERT, UPDATE, DELETE, or MERGE statement that references at least
4757
   * one collection in its VALUES or WHERE clause. Performance benefits apply only to
4758
   * collection references that use index as an index.
4759
   * Every collection that dml_statement references must have indexes that match the
4760
   * values of index. If you apply the DELETE, EXTEND, or TRIM method to one collection,
4761
   * apply it to the other collections also, so that all collections have the same set of indexes.
4762
   * If any collection lacks a referenced element, PL/SQL raises an exception.
4763
   *
4764
   * Restriction on dml_statement If dml_statement is a dynamic SQL statement, then
4765
   * values in the USING clause (bind variables for the dynamic SQL statement) must be
4766
   * simple references to the collection, not expressions. For example, collection(i) is
4767
   * valid, but UPPER(collection(i)) is invalid.
4768
   */
4769
  int ret = OB_SUCCESS;
4770
  const ObPLStmtBlock *body_block = NULL;
4771
  CK (OB_NOT_NULL(body_block = stmt.get_body()));
4772
  CK (OB_LIKELY(1 == body_block->get_child_size()));
4773
  CK (OB_NOT_NULL(body_block->get_child_stmt(0)));
4774
  CK (OB_LIKELY(PL_SQL == body_block->get_child_stmt(0)->get_type())
4775
      || OB_LIKELY(PL_EXECUTE == body_block->get_child_stmt(0)->get_type()));
4776
  if (PL_EXECUTE == body_block->get_child_stmt(0)->get_type()) {
4777
    const ObPLExecuteStmt *execute_stmt
4778
      = static_cast<const ObPLExecuteStmt *>(body_block->get_child_stmt(0));
4779
    ObSEArray<int64_t, 3> params;
4780
    const ObIArray<InOutParam> *using_params = NULL;
4781
    CK (OB_NOT_NULL(execute_stmt));
4782
    CK (OB_NOT_NULL(using_params = &(execute_stmt->get_using())));
4783
    if (execute_stmt->get_into().count() && !execute_stmt->get_is_returning()) {
4784
      ret= OB_ERR_FORALL_BULK_TOGETHER;
4785
      LOG_WARN("PLS-00432: implementation restriction: cannot use FORALL and BULK COLLECT INTO"
4786
               " together in SELECT statements", K(ret));
4787
    }
4788
    for (int64_t i = 0; OB_SUCC(ret) && i < using_params->count(); ++i) {
4789
      OZ (params.push_back(using_params->at(i).param_));
4790
    }
4791
    if (OB_SUCC(ret) && params.count() <= 0) {
4792
        ret = OB_ERR_FORALL_DML_WITHOUT_BULK;
4793
        LOG_WARN("PLS-00435: DML statement without BULK In-BIND cannot be used inside FORALL.",
4794
                 K(ret), K(params.count()));
4795
    }
4796
    ObSEArray<int64_t, 16> need_modify_exprs;
4797
    bool can_array_binding = true;
4798
    for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
4799
      ObRawExpr* exec_param = func.get_expr(params.at(i));
4800
      bool need_modify = false;
4801
      CK (OB_NOT_NULL(exec_param));
4802
      OZ (check_raw_expr_in_forall(exec_param, stmt.get_ident(), need_modify, can_array_binding));
4803
      if (OB_SUCC(ret)) {
4804
        if (need_modify) {
4805
          OZ (need_modify_exprs.push_back(i));
4806
        }
4807
      }
4808
    }
4809
    if (OB_SUCC(ret) && 0 == need_modify_exprs.count()) {
4810
      ret = OB_ERR_FORALL_DML_WITHOUT_BULK;
4811
      LOG_WARN("PLS-00435: DML statement without BULK In-BIND cannot be used inside FORALL.",
4812
               K(ret), K(params.count()));
4813
    }
4814
    stmt.set_binding_array(false);
4815
  } else {
4816
    const ObPLSqlStmt* const_sql_stmt = NULL;
4817
    ObPLSqlStmt* sql_stmt = NULL;
4818
    CK (OB_NOT_NULL(const_sql_stmt
4819
      = static_cast<const ObPLSqlStmt*>(body_block->get_child_stmt(0))));
4820
    CK (OB_NOT_NULL(sql_stmt = const_cast<ObPLSqlStmt*>(const_sql_stmt)));
4821
    if (OB_SUCC(ret)
4822
        && sql_stmt->get_stmt_type() != stmt::T_INSERT
4823
        && sql_stmt->get_stmt_type() != stmt::T_SELECT
4824
        && sql_stmt->get_stmt_type() != stmt::T_DELETE
4825
        && sql_stmt->get_stmt_type() != stmt::T_UPDATE) {
4826
      ret = OB_NOT_SUPPORTED;
4827
      LOG_WARN("forall support dml sql only", K(ret), K(sql_stmt->get_stmt_type()));
4828
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "not dml sql in forall");
4829
    } else if (sql_stmt->has_link_table()) {
4830
      ret = OB_ERR_FORALL_ON_REMOTE_TABLE;
4831
      LOG_WARN("FORALL INSERT/UPDATE/DELETE not support on remote tables", K(ret), K(sql_stmt->get_stmt_type()));
4832
    }
4833
    if (OB_SUCC(ret)) {
4834
      // Restriction:
4835
      // PLS-00432: implementation restriction: cannot use FORALL and BULK COLLECT INTO together in SELECT statements
4836
      // PLS-00435: DML statement without BULK In-BIND cannot be used inside FORALL
4837
      // PLS-00430: FORALL iteration variable INDX is not allowed in this context
4838
      const common::ObIArray<int64_t>& params = sql_stmt->get_params();
4839
      if (OB_SUCC(ret) && params.count() <= 0) {
4840
          ret = OB_ERR_FORALL_DML_WITHOUT_BULK;
4841
          LOG_WARN("PLS-00435: DML statement without BULK In-BIND cannot be used inside FORALL.", K(ret), K(params.count()));
4842
      }
4843
      ObSEArray<int64_t, 16> need_modify_exprs;
4844
      bool can_array_binding = true;
4845
      for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
4846
        ObRawExpr* exec_param = func.get_expr(params.at(i));
4847
        bool need_modify = false;
4848
        bool is_array_binding = true;
4849
        CK (OB_NOT_NULL(exec_param));
4850
        OZ (check_raw_expr_in_forall(exec_param, stmt.get_ident(), need_modify, is_array_binding));
4851
        if (OB_SUCC(ret)) {
4852
          if (need_modify) {
4853
            OZ (need_modify_exprs.push_back(i));
4854
          }
4855
          OZ (sql_stmt->get_array_binding_params().push_back(params.at(i)));
4856
        }
4857
        can_array_binding &= is_array_binding;
4858
      }
4859
      if (OB_SUCC(ret) && 0 == need_modify_exprs.count()) {
4860
        ret = OB_ERR_FORALL_DML_WITHOUT_BULK;
4861
        LOG_WARN("PLS-00435: DML statement without BULK In-BIND cannot be used inside FORALL.", K(ret), K(params.count()));
4862
      }
4863
      if (OB_FAIL(ret)) {
4864
      } else if (stmt.is_values_bound() || stmt.is_indices_bound() || stmt.is_indices_with_between_bound()) {
4865
        stmt.set_binding_array(false);
4866
      } else if (can_array_binding) {
4867
        stmt.set_binding_array(true);
4868
      }
4869
      if (OB_SUCC(ret) && StmtType::T_SELECT == sql_stmt->get_stmt_type()) {
4870
        ret = OB_ERR_FORALL_BULK_TOGETHER;
4871
        LOG_WARN("PLS-00432: implementation restriction: cannot use FORALL and BULK COLLECT INTO together in SELECT statements", K(ret));
4872
      }
4873
      if (OB_SUCC(ret) && stmt.get_binding_array()) {
4874
        OZ (modify_raw_expr_in_forall(stmt, func, *sql_stmt, need_modify_exprs));
4875
        if (OB_SUCC(ret)) {
4876
          stmt.set_sql_stmt(sql_stmt);
4877
        }
4878
      }
4879
    }
4880
  }
4881
  return ret;
4882
}
4883

4884
int ObPLResolver::resolve_forall_collection_and_check(const ObStmtNodeTree *coll_node,
4885
                                                      ObPLForAllStmt *stmt,
4886
                                                      ObPLFunctionAST &func,
4887
                                                      ObIArray<ObObjAccessIdx> &access_idxs)
4888
{
4889
  int ret = OB_SUCCESS;
4890
  ObArray<ObObjAccessIdent> obj_access_idents;
4891
  const ObUserDefinedType *user_type = NULL;
4892
  CK (OB_NOT_NULL(coll_node));
4893
  CK (OB_NOT_NULL(current_block_));
4894
  CK (T_SP_OBJ_ACCESS_REF == coll_node->type_);
4895
  OZ (resolve_obj_access_idents(*coll_node, obj_access_idents, func));
4896
  for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_idents.count(); ++i) {
4897
    OZ (resolve_access_ident(obj_access_idents.at(i),
4898
                             current_block_->get_namespace(),
4899
                             expr_factory_,
4900
                             &resolve_ctx_.session_info_,
4901
                             access_idxs,
4902
                             func));
4903
  }
4904
  if (OB_FAIL(ret)) {
4905
  } else if (!ObObjAccessIdx::get_final_type(access_idxs).is_collection_type()) {
4906
    ret = OB_ERR_SHOULD_COLLECTION_TYPE;
4907
    LOG_WARN("PLS-00668: Type of expression should be a collection type",
4908
             K(ret), K(ObObjAccessIdx::get_final_type(access_idxs)));
4909
  } else {
4910
    OZ (current_block_->get_namespace().get_pl_data_type_by_id(
4911
      ObObjAccessIdx::get_final_type(access_idxs).get_user_type_id(), user_type));
4912
    CK (OB_NOT_NULL(user_type));
4913
  }
4914
#ifdef OB_BUILD_ORACLE_PL
4915
  if (OB_SUCC(ret)) {
4916
    const ObCollectionType *coll_type = static_cast<const ObCollectionType*>(user_type);
4917
    CK (OB_NOT_NULL(coll_type));
4918
    if (OB_FAIL(ret)) {
4919
    } else if (stmt->is_values_bound() && !coll_type->get_element_type().is_pl_integer_type()) {
4920
      ret = OB_ERR_ASSOC_ELEM_TYPE;
4921
      LOG_WARN(
4922
        "PLS-00667: Element type of associative array should be pls_integer or binary_integer",
4923
        K(ret), K(coll_type->get_element_type()));
4924
    } else if (coll_type->is_associative_array_type()) {
4925
      const ObAssocArrayType *assoc_type = static_cast<const ObAssocArrayType*>(user_type);
4926
      CK (OB_NOT_NULL(assoc_type));
4927
      if (OB_FAIL(ret)) {
4928
      } else if (!assoc_type->get_index_type().is_pl_integer_type()) {
4929
        ret = OB_ERR_UNSUPPORTED_TABLE_INDEX_TYPE;
4930
        LOG_WARN("PLS-00315: Implementation restriction: unsupported table index type",
4931
                 K(ret), K(assoc_type->get_index_type()));
4932
      }
4933
    }
4934
  }
4935
#endif
4936
  return ret;
4937
}
4938

4939
int ObPLResolver::build_forall_index_expr(ObPLForAllStmt *stmt,
4940
                                          ObRawExprFactory &expr_factory,
4941
                                          ObRawExpr *&expr)
4942
{
4943
  int ret = OB_SUCCESS;
4944
  ObConstRawExpr *c_expr = NULL;
4945
  ObExprResType res_type;
4946
  ObObjParam val;
4947
  ObPLDataType data_type;
4948
  OZ (expr_factory.create_raw_expr(T_QUESTIONMARK, c_expr));
4949
  CK (OB_NOT_NULL(c_expr));
4950
  OX (val.set_unknown(stmt->get_ident()));
4951
  OX (val.set_param_meta());
4952
  OX (c_expr->set_value(val));
4953
  OZ (build_pl_integer_type(PL_PLS_INTEGER, data_type));
4954
  CK (OB_NOT_NULL(data_type.get_data_type()));
4955
  OX (res_type.set_meta(data_type.get_data_type()->get_meta_type()));
4956
  OX (res_type.set_accuracy(data_type.get_data_type()->get_accuracy()));
4957
  OX (c_expr->set_result_type(res_type));
4958
  OZ (c_expr->add_flag(IS_DYNAMIC_PARAM));
4959
  OZ (c_expr->extract_info());
4960
  OX (expr = c_expr);
4961
  return ret;
4962
}
4963

4964
int ObPLResolver::build_collection_value_expr(ObIArray<ObObjAccessIdx> &access_idxs,
4965
                                              ObPLFunctionAST &func,
4966
                                              ObPLForAllStmt *stmt,
4967
                                              ObPLDataType *expected_type)
4968
{
4969
  int ret = OB_SUCCESS;
4970
  ObObjAccessIdx access_idx;
4971
  ObRawExpr *expr = NULL;
4972

4973
  new (&access_idx) ObObjAccessIdx(*expected_type,
4974
                                   ObObjAccessIdx::AccessType::IS_LOCAL,
4975
                                   ObString(""),
4976
                                   *expected_type,
4977
                                   stmt->get_ident());
4978
  OZ (access_idxs.push_back(access_idx));
4979
  OZ (make_var_from_access(access_idxs,
4980
                           expr_factory_,
4981
                           &(resolve_ctx_.session_info_),
4982
                           &(resolve_ctx_.schema_guard_),
4983
                           current_block_->get_namespace(),
4984
                           expr));
4985
  CK (OB_NOT_NULL(expr));
4986
  if (OB_SUCC(ret) && expr->is_obj_access_expr()) {
4987
    OZ (func.add_obj_access_expr(expr));
4988
  }
4989
  OZ (func.add_expr(expr));
4990
  OX (access_idxs.pop_back());
4991
  OX (stmt->set_value(func.get_expr_count() - 1));
4992
  return ret;
4993
}
4994

4995
int ObPLResolver::build_collection_property_expr(const ObString &property_name,
4996
                                                 ObIArray<ObObjAccessIdx> &access_idxs,
4997
                                                 ObPLFunctionAST &func,
4998
                                                 ObPLForAllStmt *stmt,
4999
                                                 ObPLDataType *expected_type)
5000
{
5001
  int ret = OB_SUCCESS;
5002
  const ObUserDefinedType *user_type = NULL;
5003
  uint64_t package_id = OB_INVALID_ID;
5004
  int64_t var_idx = OB_INVALID_INDEX;
5005
  ObObjAccessIdx access_idx;
5006
  ObObjAccessIdent access_ident;
5007
  ObPLDataType type;
5008
  ObRawExpr *expr = NULL;
5009
  ObRawExpr *index_expr = NULL;
5010
  const ObDataType *data_type = NULL;
5011
  OZ (current_block_->get_namespace().get_pl_data_type_by_id(
5012
    ObObjAccessIdx::get_final_type(access_idxs).get_user_type_id(), user_type));
5013
  CK (OB_NOT_NULL(user_type));
5014
  OX (access_ident.access_name_ = property_name);
5015
  OZ (build_forall_index_expr(stmt, expr_factory_, index_expr));
5016
  CK (OB_NOT_NULL(index_expr));
5017
  OX (access_ident.params_.push_back(std::make_pair(index_expr, 0)));
5018
  OZ (current_block_->get_namespace().find_sub_attr_by_name(
5019
    *user_type,
5020
    access_ident,
5021
    resolve_ctx_.session_info_,
5022
    expr_factory_,
5023
    func,
5024
    access_idx,
5025
    type,
5026
    package_id,
5027
    var_idx));
5028
  if (OB_SUCC(ret)
5029
      && (0 == property_name.case_compare("next") || 0 == property_name.case_compare("exists"))) {
5030
    if (user_type->is_associative_array_type()) {
5031
      ObObjAccessIdx tmp_access_idx;
5032
      ObPLAssocIndexRawExpr *index_expr = NULL;
5033
      OZ (build_collection_attribute_access(expr_factory_,
5034
                                            &(resolve_ctx_.session_info_),
5035
                                            current_block_->get_namespace(),
5036
                                            func,
5037
                                            *user_type,
5038
                                            access_idxs,
5039
                                            OB_INVALID_INDEX,
5040
                                            access_ident.params_.at(0).first,
5041
                                            tmp_access_idx));
5042
      CK (OB_NOT_NULL(index_expr =
5043
            static_cast<ObPLAssocIndexRawExpr *>(tmp_access_idx.get_sysfunc_)));
5044
      OX (index_expr->set_out_of_range_set_err(false));
5045
      OX (index_expr->set_parent_type(
5046
        0 == property_name.case_compare("next") ?
5047
          parent_expr_type::EXPR_NEXT : parent_expr_type::EXPR_EXISTS));
5048
      OX (access_idx.get_sysfunc_ = tmp_access_idx.get_sysfunc_);
5049
    } else {
5050
      access_idx.get_sysfunc_ = access_ident.params_.at(0).first;
5051
    }
5052
  }
5053
  OZ (access_idxs.push_back(access_idx));
5054
  OZ (make_var_from_access(access_idxs,
5055
                           expr_factory_,
5056
                           &(resolve_ctx_.session_info_),
5057
                           &(resolve_ctx_.schema_guard_),
5058
                           current_block_->get_namespace(),
5059
                           expr));
5060
  if (OB_SUCC(ret) && expr->is_obj_access_expr()) {
5061
    OZ (func.add_obj_access_expr(expr));
5062
  }
5063
  if (property_name.case_compare("next")
5064
      || property_name.case_compare("first")
5065
      || property_name.case_compare("last")) {
5066
    CK (OB_NOT_NULL(data_type = expected_type->get_data_type()));
5067
    OZ (ObRawExprUtils::build_column_conv_expr(&resolve_ctx_.session_info_,
5068
                                               expr_factory_,
5069
                                               data_type->get_obj_type(),
5070
                                               data_type->get_collation_type(),
5071
                                               data_type->get_accuracy_value(),
5072
                                               true,
5073
                                               NULL, /*"db_name"."tb_name"."col_name"*/
5074
                                               &expected_type->get_type_info(),
5075
                                               expr,
5076
                                               true /*is_in_pl*/));
5077
  }
5078
  OZ (func.add_expr(expr));
5079
  OX (access_idxs.pop_back());
5080

5081
  return ret;
5082
}
5083

5084
int ObPLResolver::resolve_forall_collection_node(const ObStmtNodeTree *collection_node,
5085
                                                 ObPLForAllStmt *stmt,
5086
                                                 ObPLFunctionAST &func,
5087
                                                 ObPLDataType *expected_type)
5088
{
5089
  int ret = OB_SUCCESS;
5090
  ObArray<ObObjAccessIdx> access_idxs;
5091

5092
  CK (OB_NOT_NULL(stmt));
5093
  OZ (resolve_forall_collection_and_check(collection_node, stmt, func, access_idxs));
5094

5095
#define BUILD_PROPERTY_EXPR(name) \
5096
do { \
5097
  OZ (build_collection_property_expr(ObString(#name), access_idxs, func, stmt, expected_type)); \
5098
  OX (stmt->set_##name(func.get_expr_count() - 1)); \
5099
} while(0)
5100

5101
  if (OB_SUCC(ret)
5102
      && (stmt->is_indices_bound() || stmt->is_values_bound())) {
5103
    BUILD_PROPERTY_EXPR(first);
5104
    BUILD_PROPERTY_EXPR(last);
5105
  }
5106
  BUILD_PROPERTY_EXPR(next);
5107

5108
  if (OB_FAIL(ret)) {
5109
  } else if (stmt->is_values_bound()) {
5110
    OZ (build_collection_value_expr(access_idxs, func, stmt, expected_type));
5111
  } else if (stmt->is_indices_with_between_bound()) {
5112
    BUILD_PROPERTY_EXPR(exists);
5113
  }
5114

5115
#undef BUILD_PROPERTY_EXPR
5116

5117
  return ret;
5118
}
5119

5120
int ObPLResolver::resolve_indices_bound_clause(const ObStmtNodeTree &indices_of_node,
5121
                                               ObPLForAllStmt *stmt,
5122
                                               ObPLFunctionAST &func,
5123
                                               ObPLDataType *expected_type)
5124
{
5125
  int ret = OB_SUCCESS;
5126
  const ObStmtNodeTree* collection_node = NULL;
5127
  const ObStmtNodeTree* between_node = NULL;
5128
  CK (OB_NOT_NULL(stmt));
5129
  CK (T_SP_INDICES_OF_CALUSE == indices_of_node.type_);
5130
  CK (2 == indices_of_node.num_child_);
5131
  CK (OB_NOT_NULL(collection_node = indices_of_node.children_[0]));
5132
  OX (between_node = indices_of_node.children_[1]);
5133
  if (OB_SUCC(ret) && OB_NOT_NULL(between_node)) {
5134
    OZ (resolve_normal_bound_clause(*between_node, stmt, func, expected_type));
5135
  }
5136
  OX (stmt->set_bound_type(OB_NOT_NULL(between_node)
5137
                           ? ObPLForLoopStmt::BoundType::INDICES_WITH_BETWEEN
5138
                           : ObPLForLoopStmt::BoundType::INDICES));
5139
  OZ (resolve_forall_collection_node(collection_node, stmt, func, expected_type));
5140
  return ret;
5141
}
5142

5143
int ObPLResolver::resolve_values_bound_clause(const ObStmtNodeTree &values_of_node,
5144
                                              ObPLForAllStmt *stmt,
5145
                                              ObPLFunctionAST &func,
5146
                                              ObPLDataType *expected_type)
5147
{
5148
  int ret = OB_SUCCESS;
5149
  const ObStmtNodeTree* collection_node = NULL;
5150
  CK (OB_NOT_NULL(stmt));
5151
  CK (T_SP_VALUES_OF_CALUSE == values_of_node.type_);
5152
  CK (1 == values_of_node.num_child_);
5153
  CK (OB_NOT_NULL(collection_node = values_of_node.children_[0]));
5154
  OX (stmt->set_bound_type(ObPLForLoopStmt::BoundType::VALUES));
5155
  OZ (resolve_forall_collection_node(collection_node, stmt, func, expected_type));
5156
  return ret;
5157
}
5158

5159
int ObPLResolver::resolve_normal_bound_clause(const ObStmtNodeTree &bound_node,
5160
                                              ObPLForAllStmt *stmt,
5161
                                              ObPLFunctionAST &func,
5162
                                              ObPLDataType *expected_type)
5163
{
5164
  int ret = OB_SUCCESS;
5165
  const ObStmtNodeTree* lower_node = NULL;
5166
  const ObStmtNodeTree* upper_node = NULL;
5167
  ObRawExpr *lower_expr = NULL;
5168
  ObRawExpr *upper_expr = NULL;
5169
  CK (OB_NOT_NULL(stmt));
5170
  CK (T_SP_BOUND_CLAUSE == bound_node.type_);
5171
  CK (2 == bound_node.num_child_);
5172
  CK (OB_NOT_NULL(bound_node.children_));
5173
  CK (OB_NOT_NULL(lower_node = bound_node.children_[0]));
5174
  CK (OB_NOT_NULL(upper_node = bound_node.children_[1]));
5175
  OZ (resolve_expr(
5176
    lower_node, static_cast<ObPLCompileUnitAST&>(func), lower_expr,
5177
    combine_line_and_col(lower_node->stmt_loc_), true, expected_type));
5178
  OZ (resolve_expr(
5179
    upper_node, static_cast<ObPLCompileUnitAST&>(func), upper_expr,
5180
    combine_line_and_col(upper_node->stmt_loc_), true, expected_type));
5181
  OX (stmt->set_lower(func.get_expr_count() - 2));
5182
  OX (stmt->set_upper(func.get_expr_count() - 1));
5183
  OX (stmt->set_bound_type(ObPLForLoopStmt::BoundType::NORMAL));
5184
  return ret;
5185
}
5186

5187
int ObPLResolver::resolve_forall_bound_clause(const ObStmtNodeTree &parse_tree,
5188
                                              ObPLForAllStmt *stmt,
5189
                                              ObPLFunctionAST &func,
5190
                                              ObPLDataType *expected_type)
5191
{
5192
  int ret = OB_SUCCESS;
5193
  switch (parse_tree.type_) {
5194
    case T_SP_BOUND_CLAUSE: {
5195
      OZ (resolve_normal_bound_clause(parse_tree, stmt, func, expected_type));
5196
    } break;
5197
    case T_SP_INDICES_OF_CALUSE: {
5198
      OZ (resolve_indices_bound_clause(parse_tree, stmt, func, expected_type));
5199
    } break;
5200
    case T_SP_VALUES_OF_CALUSE: {
5201
      OZ (resolve_values_bound_clause(parse_tree, stmt, func, expected_type));
5202
    } break;
5203
    default: {
5204
      ret = OB_ERR_UNEXPECTED;
5205
      LOG_WARN("unexpected bound clause type", K(ret), K(parse_tree.type_));
5206
    }
5207
  }
5208
  return ret;
5209
}
5210

5211
int ObPLResolver::resolve_forall(const ObStmtNodeTree *parse_tree,
5212
                                 ObPLForAllStmt *stmt,
5213
                                 ObPLFunctionAST &func)
5214
{
5215
  int ret = OB_SUCCESS;
5216

5217
  CK (OB_NOT_NULL(parse_tree),
5218
      OB_NOT_NULL(stmt),
5219
      3 == parse_tree->num_child_,
5220
      OB_NOT_NULL(parse_tree->children_[0]),
5221
      OB_NOT_NULL(parse_tree->children_[1]));
5222

5223
  if (OB_FAIL(ret)) {
5224
  } else if (OB_ISNULL(parse_tree->children_[2])) {
5225
    ret = OB_NOT_SUPPORTED;
5226
    LOG_WARN("for all dml must be not null", K(ret));
5227
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "null dml in forall");
5228
  } else {
5229
    const ObStmtNodeTree* index_node = parse_tree->children_[0];
5230
    const ObStmtNodeTree* bound_node = parse_tree->children_[1];
5231
    const ObStmtNodeTree* body_node = parse_tree->children_[2];
5232
    bool save_exception = static_cast<bool>(parse_tree->value_);
5233
    ObPLDataType data_type;
5234
    ObPLStmtBlock *body_block = NULL;
5235
    ObString index_name;
5236

5237
    // 解析svae_exception
5238
    OX (stmt->set_save_exception(save_exception));
5239

5240
    // 解析index
5241
    OZ (build_pl_integer_type(PL_PLS_INTEGER, data_type));
5242
    OZ (make_block(func, current_block_, body_block, true));
5243
    CK (OB_NOT_NULL(body_block));
5244
    OZ (resolve_ident(index_node, index_name));
5245
    OZ (body_block->get_namespace().add_symbol(index_name, data_type, NULL, true));
5246
    OX (stmt->set_ident(func.get_symbol_table().get_count() - 1));
5247

5248
    // 解析bound
5249
    OZ (resolve_forall_bound_clause(*bound_node, stmt, func, &data_type));
5250

5251
    // 解析body
5252
    OZ (resolve_stmt_list(body_node, body_block, func));
5253
    OX (stmt->set_body(body_block));
5254

5255
    // for ArrayBinding优化
5256
    OZ (stmt->create_tab_to_subtab());
5257

5258
    // 检查sql语句以及Index使用的合法性
5259
    OZ (check_forall_sql_and_modify_params(*stmt, func));
5260
  }
5261
  return ret;
5262
}
5263

5264
int ObPLResolver::resolve_repeat(const ObStmtNodeTree *parse_tree, ObPLRepeatStmt *stmt, ObPLFunctionAST &func)
5265
{
5266
  int ret = OB_SUCCESS;
5267
  if (OB_ISNULL(parse_tree)) {
5268
    ret = OB_INVALID_ARGUMENT;
5269
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(ret));
5270
  } else {
5271
    const ObStmtNodeTree *expr_node = parse_tree->children_[1];
5272
    const ObStmtNodeTree *body_node = parse_tree->children_[0];
5273
    if (OB_FAIL(resolve_cond_loop(expr_node, body_node, stmt, func))) {
5274
      LOG_WARN("failed to resolve while", K(parse_tree), K(stmt), K(ret));
5275
    }
5276
  }
5277
  return ret;
5278
}
5279

5280
int ObPLResolver::resolve_loop(const ObStmtNodeTree *parse_tree, ObPLLoopStmt *stmt, ObPLFunctionAST &func)
5281
{
5282
  int ret = OB_SUCCESS;
5283
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
5284
    ret = OB_INVALID_ARGUMENT;
5285
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(ret));
5286
  } else {
5287
    //解析body
5288
    if (OB_ISNULL(parse_tree->children_[0])) {
5289
      ret = OB_ERR_UNEXPECTED;
5290
      LOG_WARN("Invalid loop body", K(parse_tree->children_[0]->type_), K(ret));
5291
    } else if (T_SP_PROC_STMT_LIST != parse_tree->children_[0]->type_) {
5292
      ret = OB_ERR_UNEXPECTED;
5293
      LOG_WARN("Invalid loop body", K(parse_tree->children_[0]->type_), K(ret));
5294
    } else {
5295
      ObPLStmtBlock *body_block = NULL;
5296
      if (OB_FAIL(resolve_stmt_list(parse_tree->children_[0], body_block, func))) {
5297
        LOG_WARN("failed to resolve stmt list", K(parse_tree->children_[0]->type_), K(ret));
5298
      } else {
5299
        stmt->set_body(body_block);
5300
      }
5301
    }
5302
  }
5303
  return ret;
5304
}
5305

5306
int ObPLResolver::resolve_return(const ObStmtNodeTree *parse_tree, ObPLReturnStmt *stmt, ObPLFunctionAST &func)
5307
{
5308
  int ret = OB_SUCCESS;
5309
  CK (OB_NOT_NULL(parse_tree));
5310
  CK (OB_NOT_NULL(stmt));
5311

5312
  if (OB_SUCC(ret) && !func.is_function()) {
5313
    if (lib::is_mysql_mode()) {
5314
      ret = OB_ER_SP_BADRETURN;
5315
      LOG_WARN("RETURN is only allowed in a FUNCTION", K(ret));
5316
      LOG_USER_ERROR(OB_ER_SP_BADRETURN);
5317
    }
5318
  }
5319

5320
  if (OB_SUCC(ret)) {
5321
    ObRawExpr *expr = NULL;
5322
    ObStmtNodeTree *expr_node = parse_tree->children_[0];
5323
#ifdef OB_BUILD_ORACLE_PL
5324
    if (func.is_udt_cons()) {
5325
      if (OB_NOT_NULL(expr_node)) {
5326
        ret = OB_ERR_CONS_HAS_RET_NODE;
5327
        LOG_WARN("udt constructor should not have return expr", K(ret));
5328
        LOG_USER_ERROR(OB_ERR_CONS_HAS_RET_NODE);
5329
      } else {
5330
        ParseNode *child = NULL;
5331
        ParseNode *parent = NULL;
5332
        if (NULL == (child = new_terminal_node(&resolve_ctx_.allocator_, T_IDENT))) {
5333
          ret = OB_ALLOCATE_MEMORY_FAILED;
5334
          LOG_WARN("failed to alloc memory", K(ret));
5335
        } else if (NULL == (parent = new_non_terminal_node(&resolve_ctx_.allocator_, T_OBJ_ACCESS_REF, 2, child, NULL))) {
5336
          ret = OB_ALLOCATE_MEMORY_FAILED;
5337
          LOG_WARN("failed to alloc memory", K(ret));
5338
        } else {
5339
          child->str_value_ = "SELF";
5340
          child->str_len_ = 4;
5341
          child->raw_text_ = "SELF";
5342
          child->text_len_ = 4;
5343
          expr_node = parent;
5344
        }
5345
      }
5346
    }
5347
#endif
5348
    if (OB_FAIL(ret)) {
5349
      // do nothing
5350
    } else if (OB_ISNULL(expr_node)) {
5351
      if (lib::is_mysql_mode()
5352
          || (func.is_function() && !func.get_pipelined())) {
5353
        ret = OB_ERR_RETURN_VALUE_REQUIRED;
5354
        LOG_WARN("not allow return expr node is null in function", K(ret), K(expr_node));
5355
      }
5356
    } else if (!func.is_function()) {
5357
      ret = OB_ER_SP_BADRETURN;
5358
      LOG_WARN("not allow return expr node is not null in procedure", K(ret), K(func.is_function()));
5359
    } else if (func.get_pipelined()) {
5360
      ret = OB_ERR_RETURN_EXPR_ILLEGAL;
5361
      LOG_WARN("PLS-00633: RETURN statement in a pipelined function cannot contain an expression",
5362
               K(ret), K(func));
5363
    } else if (OB_FAIL(resolve_expr(expr_node, func, expr,
5364
                                    combine_line_and_col(expr_node->stmt_loc_),
5365
                                    true, &func.get_ret_type()))) {
5366
      LOG_WARN("failed to resolve expr", K(expr_node), K(ret));
5367
    } else {
5368
      stmt->set_ret(func.get_expr_count() - 1);
5369
      bool is_ref_cursor_type = false;
5370
      OZ (is_return_ref_cursor_type(expr, is_ref_cursor_type));
5371
      OX (stmt->set_is_ref_cursor_type(is_ref_cursor_type));
5372
      LOG_DEBUG("return ref cursor type: ", K(is_ref_cursor_type));
5373
    }
5374
  }
5375

5376
  return ret;
5377
}
5378

5379
int ObPLResolver::check_and_record_stmt_type(ObPLFunctionAST &func,
5380
                                             sql::ObSPIService::ObSPIPrepareResult &prepare_result)
5381
{
5382
  // FUNCTION 中不允许含有的SQL语句包括 PS, DDL, SELECT WITHOUT INTO
5383
  int ret = OB_SUCCESS;
5384
  stmt::StmtType type = prepare_result.type_;
5385
  bool in_tg = resolve_ctx_.session_info_.is_for_trigger_package();
5386
  switch (type) {
5387
    case stmt::T_PREPARE:
5388
    case stmt::T_EXECUTE:
5389
    case stmt::T_DEALLOCATE: {
5390
      if (func.is_function() || in_tg) {
5391
        ret = OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG;
5392
        LOG_WARN("Dynamic SQL is not allowed in stored function", K(ret));
5393
        LOG_USER_ERROR(OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, "Dynamic SQL");
5394
      } else {
5395
        func.set_contain_dynamic_sql();
5396
      }
5397
      break;
5398
    }
5399
    case stmt::T_SELECT:
5400
    case stmt::T_EXPLAIN:
5401
    case stmt::T_SHOW_COLUMNS:
5402
    case stmt::T_SHOW_TABLES:
5403
    case stmt::T_SHOW_DATABASES:
5404
    case stmt::T_SHOW_TABLE_STATUS:
5405
    case stmt::T_SHOW_SERVER_STATUS:
5406
    case stmt::T_SHOW_VARIABLES:
5407
    case stmt::T_SHOW_SCHEMA:
5408
    case stmt::T_SHOW_CREATE_DATABASE:
5409
    case stmt::T_SHOW_CREATE_TABLE:
5410
    case stmt::T_SHOW_CREATE_VIEW:
5411
    case stmt::T_SHOW_WARNINGS:
5412
    case stmt::T_SHOW_ERRORS:
5413
    case stmt::T_SHOW_GRANTS:
5414
    case stmt::T_SHOW_CHARSET:
5415
    case stmt::T_SHOW_COLLATION:
5416
    case stmt::T_SHOW_PARAMETERS:
5417
    case stmt::T_SHOW_INDEXES:
5418
    case stmt::T_SHOW_PROCESSLIST:
5419
    case stmt::T_SHOW_TABLEGROUPS:
5420
    case stmt::T_HELP:
5421
    case stmt::T_SHOW_RECYCLEBIN:
5422
    case stmt::T_SHOW_RESTORE_PREVIEW:
5423
    case stmt::T_SHOW_TENANT:
5424
    case stmt::T_SHOW_SEQUENCES:
5425
    case stmt::T_SHOW_STATUS:
5426
    case stmt::T_SHOW_CREATE_TENANT:
5427
    case stmt::T_SHOW_TRACE:
5428
    case stmt::T_SHOW_ENGINES:
5429
    case stmt::T_SHOW_PRIVILEGES:
5430
    case stmt::T_SHOW_CREATE_PROCEDURE:
5431
    case stmt::T_SHOW_CREATE_FUNCTION:
5432
    case stmt::T_SHOW_PROCEDURE_STATUS:
5433
    case stmt::T_SHOW_FUNCTION_STATUS:
5434
    case stmt::T_SHOW_CREATE_TABLEGROUP:
5435
    case stmt::T_SHOW_CREATE_TRIGGER:
5436
    case stmt::T_SHOW_QUERY_RESPONSE_TIME:
5437
    case stmt::T_SHOW_TRIGGERS: {
5438
      if (0 == prepare_result.into_exprs_.count()) {
5439
        if (func.is_function() || in_tg) {
5440
          ret = OB_ER_SP_NO_RETSET;
5441
          LOG_WARN("Not allowed to return a result set in pl function", K(ret));
5442
          if (in_tg) {
5443
            LOG_USER_ERROR(OB_ER_SP_NO_RETSET, "trigger");
5444
          } else {
5445
            LOG_USER_ERROR(OB_ER_SP_NO_RETSET, "function");
5446
          }
5447
        } else {
5448
          func.set_multi_results();
5449
        }
5450
      }
5451
      break;
5452
    }
5453
    default: {
5454
      if (ObStmt::is_ddl_stmt(type, false)
5455
          || ObStmt::is_dcl_stmt(type)
5456
          || ObStmt::is_tcl_stmt(type)) {
5457
        if (func.is_function() || in_tg) {
5458
          ret = OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG;
5459
          LOG_WARN("DDL SQL is not allowed in stored function", K(ret));
5460
          LOG_USER_ERROR(OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG);
5461
        } else {
5462
          func.set_has_commit_or_rollback();
5463
        }
5464
      }
5465
    }
5466
    break;
5467
  }
5468
  return ret;
5469
}
5470

5471
int ObPLResolver::replace_plsql_line(
5472
  ObIAllocator &allocator, const ObStmtNodeTree *node, ObString &sql, ObString &new_sql)
5473
{
5474
  int ret = OB_SUCCESS;
5475
  if (OB_NOT_NULL(node)) {
5476
    if (T_PLSQL_VARIABLE_IDENTIFIER == node->type_) {
5477
      int64_t plsql_line = node->int32_values_[0];
5478
      int64_t first_column = node->int16_values_[2];
5479
      int64_t last_column = node->int16_values_[3];
5480

5481
      CK (first_column < sql.length() && last_column < sql.length());
5482

5483
      if (OB_SUCC(ret)
5484
          && 12 == (last_column - first_column + 1)
5485
          && 0 == ObString(12, sql.ptr() + first_column - 1).case_compare("$$PLSQL_LINE")) {
5486
        char buffer[13]; // $$PLSQL_LINE
5487
        int64_t n = snprintf(buffer, 13, "%012ld", plsql_line);
5488
        if (12 == n) {
5489
          if (new_sql.empty()) {
5490
            OZ (ob_write_string(allocator, sql, new_sql, true/*append \0*/));
5491
          }
5492
          // NOTICE: copy 12 bytes for ignore \0 tail.
5493
          OX (MEMCPY(new_sql.ptr() + first_column - 1, buffer, 12));
5494
        } else {
5495
          ret = OB_ERR_UNEXPECTED;
5496
          LOG_WARN("plsql_line format line exceed buffer size 13!",
5497
                   K(ret), K(plsql_line), K(n), K(sql), K(new_sql), K(buffer));
5498
        }
5499
      }
5500
      LOG_DEBUG("replace plsql line",
5501
                K(ObString(last_column - first_column + 1, sql.ptr() + first_column - 1)),
5502
                K(plsql_line),
5503
                K(first_column),
5504
                K(last_column),
5505
                K(sql),
5506
                K(new_sql));
5507

5508
    } else {
5509
      for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
5510
        if (OB_NOT_NULL(node->children_[i])) {
5511
          OZ (replace_plsql_line(allocator, node->children_[i], sql, new_sql));
5512
        }
5513
      }
5514
    }
5515
  }
5516
  return ret;
5517
}
5518

5519
int ObPLResolver::resolve_static_sql(const ObStmtNodeTree *parse_tree, ObPLSql &static_sql, ObPLInto &static_into, bool is_cursor, ObPLFunctionAST &func)
5520
{
5521
  int ret = OB_SUCCESS;
5522
  if (OB_ISNULL(parse_tree) || OB_ISNULL(current_block_)) {
5523
    ret = OB_INVALID_ARGUMENT;
5524
    LOG_WARN("argument is NULL", K(parse_tree), K(current_block_), K(ret));
5525
  } else {
5526
    pl::ObRecordType *record_type = NULL;
5527
    CK (T_SQL_STMT == parse_tree->type_ || T_TRANSACTION == parse_tree->type_);
5528
    if (OB_SUCC(ret)
5529
        && 1 == parse_tree->num_child_
5530
        && NULL != parse_tree->children_[0]
5531
        && T_SELECT == parse_tree->children_[0]->type_
5532
        && (NULL == ObResolverUtils::get_select_into_node(*parse_tree->children_[0])
5533
                || is_cursor)) {
5534
      if (OB_ISNULL(record_type = static_cast<ObRecordType*>(resolve_ctx_.allocator_.alloc(sizeof(ObRecordType))))) {
5535
        ret = OB_ALLOCATE_MEMORY_FAILED;
5536
        LOG_WARN("failed to alloc memory", K(ret));
5537
      } else {
5538
        record_type = new(record_type)ObRecordType();
5539
        record_type->set_type_from(PL_TYPE_ATTR_ROWTYPE);
5540
      }
5541
    }
5542
    if (OB_SUCC(ret)
5543
        && 1 == parse_tree->num_child_
5544
        && NULL != parse_tree->children_[0]
5545
        && T_DIAGNOSTICS == parse_tree->children_[0]->type_
5546
        && 0 == parse_tree->children_[0]->children_[1]->value_
5547
        && !current_block_->in_handler()) {
5548
      ret = OB_ERR_GET_STACKED_DIAGNOSTICS;
5549
      LOG_WARN("GET STACKED DIAGNOSTICS when handler not active", K(ret));
5550
    }
5551
    if (OB_SUCC(ret)) {
5552
      sql::ObSPIService::ObSPIPrepareResult prepare_result;
5553
      ObString name;
5554
      prepare_result.record_type_ = record_type;
5555
      prepare_result.tg_timing_event_ = 
5556
                            static_cast<TgTimingEvent>(resolve_ctx_.params_.tg_timing_event_);
5557
      question_mark_cnt_ = parse_tree->value_; // 更新解析到当前语句时question mark的数量(包含当前语句)
5558
      ObString new_sql;
5559
      ObString old_sql(parse_tree->str_value_);
5560
      OZ (replace_plsql_line(resolve_ctx_.allocator_, parse_tree, old_sql, new_sql));
5561
      if (OB_FAIL(ret)) {
5562
      } else if (OB_FAIL(ObSPIService::spi_prepare(resolve_ctx_.allocator_,
5563
                                            resolve_ctx_.session_info_,
5564
                                            resolve_ctx_.sql_proxy_,
5565
                                            resolve_ctx_.schema_guard_,
5566
                                            expr_factory_,
5567
                                            new_sql.empty() ?
5568
                                              parse_tree->str_value_ : new_sql.ptr(),
5569
                                            is_cursor,
5570
                                            &current_block_->get_namespace(),
5571
                                            prepare_result))) {
5572
        if (OB_ERR_TOO_BIG_DISPLAYWIDTH == ret) {
5573
          LOG_WARN("%s is too big, max is 65", K(parse_tree->str_value_), K(ret));
5574
          LOG_USER_ERROR(OB_ERR_TOO_BIG_DISPLAYWIDTH, parse_tree->str_value_, OB_MAX_BIT_LENGTH);
5575
        } else {
5576
          LOG_WARN("failed to prepare stmt", K(ret));
5577
        }
5578
      } else if (is_mysql_mode()
5579
                 && OB_FAIL(check_and_record_stmt_type(func, prepare_result))) {
5580
        LOG_WARN("sql stmt not support in pl function", K(parse_tree->str_value_), K(prepare_result.type_), K(ret));
5581
      } else if (stmt::T_SELECT == prepare_result.type_
5582
                 && 0 == prepare_result.into_exprs_.count()
5583
                 && !is_cursor
5584
                 && is_oracle_mode()) {
5585
        ret = OB_ERR_INTO_CLAUSE_EXPECTED;
5586
        LOG_WARN("PLS-00428: an INTO clause is expected in this SELECT statement", K(ret));
5587
      } else if (stmt::T_SET_PASSWORD == prepare_result.type_) {
5588
          ret = OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE;
5589
          LOG_WARN("set password in PL not allow", K(ret), K(get_type_name(parse_tree->type_)));
5590
          LOG_USER_ERROR(OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE, 12, "set PASSWORD");
5591
      } else if (is_mysql_mode() && stmt::T_LOAD_DATA == prepare_result.type_) {
5592
        name.assign_ptr("LOAD DATA", 9);
5593
        ret = OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE;
5594
        LOG_WARN("%s is not allowed in stored procedure. ", K(name), K(ret));
5595
        LOG_USER_ERROR(OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE, name.length(), name.ptr());
5596
      } else if (is_mysql_mode() && stmt::T_LOCK_TABLE == prepare_result.type_) {
5597
        name.assign_ptr("LOCK TABLE", 10);
5598
        ret = OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE;
5599
        LOG_WARN("%s is not allowed in stored procedure. ", K(name), K(ret));
5600
        LOG_USER_ERROR(OB_ERR_STMT_NOT_ALLOW_IN_MYSQL_PROCEDRUE, name.length(), name.ptr());
5601
      } else if (OB_FAIL(func.add_sql_exprs(prepare_result.exec_params_))) {
5602
        LOG_WARN("failed to set precalc exprs", K(prepare_result.exec_params_), K(ret));
5603
      } else if (OB_FAIL(func.add_sql_exprs(prepare_result.into_exprs_))) {
5604
        LOG_WARN("failed to set precalc exprs", K(prepare_result.into_exprs_), K(ret));
5605
      } else { /*do nothing*/ }
5606

5607
      if (OB_SUCC(ret)) {
5608
        if (prepare_result.for_update_) {
5609
          func.set_modifies_sql_data();
5610
        } else if (stmt::T_SELECT == prepare_result.type_) {
5611
          if (!func.is_modifies_sql_data()) {
5612
            func.set_reads_sql_data();
5613
          }
5614
        } else if (ObStmt::is_dml_write_stmt(prepare_result.type_) ||
5615
                   ObStmt::is_savepoint_stmt(prepare_result.type_) ||
5616
                   ObStmt::is_tcl_stmt(prepare_result.type_)) {
5617
          func.set_modifies_sql_data();
5618
        } else if (!func.is_reads_sql_data() && !func.is_modifies_sql_data()) {
5619
          func.set_contains_sql();
5620
        }
5621
      }
5622
      if (OB_SUCC(ret) && lib::is_oracle_mode()) {
5623
        if ((func.is_reads_sql_data() && func.get_compile_flag().compile_with_rnds())
5624
            || (func.is_modifies_sql_data() && func.get_compile_flag().compile_with_wnds())) {
5625
          ret = OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA;
5626
          LOG_WARN("PLS-00452: Subprogram 'string' violates its associated pragma",
5627
                   K(ret), K(prepare_result.type_), K(func.get_compile_flag()));
5628
          LOG_USER_ERROR(OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA, func.get_name().length(), func.get_name().ptr());
5629
        }
5630
      }
5631

5632
      if (OB_SUCC(ret)) {
5633
        ObArray<int64_t> idxs;
5634
        for (int64_t i = func.get_expr_count() - prepare_result.exec_params_.count() - prepare_result.into_exprs_.count();
5635
            OB_SUCC(ret) && i < func.get_expr_count() - prepare_result.into_exprs_.count();
5636
            ++i) {
5637
          if (OB_FAIL(idxs.push_back(i))) {
5638
            LOG_WARN("push back error", K(prepare_result.into_exprs_), K(ret));
5639
          }
5640
        }
5641
        if (OB_SUCC(ret)) {
5642
          if (OB_FAIL(static_sql.set_params(idxs))) {
5643
            LOG_WARN("failed to set params", K(prepare_result.exec_params_), K(idxs), K(ret));
5644
          }
5645
        }
5646
        if (OB_SUCC(ret)) {
5647
          const ObPLSymbolTable *table = current_block_->get_symbol_table();
5648
          CK (OB_NOT_NULL(table));
5649
          for (int64_t i = 0; OB_SUCC(ret) && i < prepare_result.exec_params_.count(); ++i) {
5650
            const ObRawExpr *expr = prepare_result.exec_params_.at(i);
5651
            const ObConstRawExpr *const_expr = NULL;
5652
            const ObPLVar *var = NULL;
5653
            CK (OB_NOT_NULL(expr));
5654
            if (OB_SUCC(ret) && T_QUESTIONMARK == expr->get_expr_type()) {
5655
              CK (OB_NOT_NULL(const_expr = static_cast<const ObConstRawExpr *>(expr)));
5656
              CK (OB_NOT_NULL(var = table->get_symbol(const_expr->get_value().get_unknown())));
5657
              if (OB_SUCC(ret) && var->get_name().prefix_match(ANONYMOUS_ARG)) {
5658
                (const_cast<ObPLVar*>(var))->set_name(ANONYMOUS_SQL_ARG);
5659
              }
5660
            }
5661
          }
5662
        }
5663
        idxs.reset();
5664
        for (int64_t i = func.get_expr_count() - prepare_result.into_exprs_.count();
5665
             OB_SUCC(ret) && i < func.get_expr_count();
5666
             ++i) {
5667
          if (OB_FAIL(idxs.push_back(i))) {
5668
            LOG_WARN("push back error", K(prepare_result.into_exprs_), K(ret));
5669
          }
5670
        }
5671
        if (OB_SUCC(ret)) {
5672
          if (prepare_result.is_bulk_) {
5673
            static_into.set_bulk();
5674
          }
5675
          if (OB_FAIL(static_into.set_into(idxs, current_block_->get_namespace(), prepare_result.into_exprs_))) {
5676
            LOG_WARN("failed to set into exprs", K(prepare_result.into_exprs_), K(idxs), K(ret));
5677
          }
5678
        }
5679
        if (OB_SUCC(ret)) {
5680
          static_sql.set_ps_sql(prepare_result.ps_sql_, prepare_result.type_);
5681
          static_sql.set_sql(prepare_result.route_sql_);
5682
          static_sql.set_for_update(prepare_result.for_update_);
5683
          static_sql.set_hidden_rowid(prepare_result.has_hidden_rowid_);
5684
          static_sql.set_link_table(prepare_result.has_link_table_);
5685
          static_sql.set_skip_locked(prepare_result.is_skip_locked_);
5686
        }
5687
      }
5688

5689
      //检查Bulk合法性
5690
      if (OB_SUCC(ret) && !prepare_result.into_exprs_.empty()) {
5691
        if (OB_ISNULL(prepare_result.into_exprs_.at(0))) {
5692
          ret = OB_ERR_UNEXPECTED;
5693
          LOG_WARN("expr is NULL", K(prepare_result.into_exprs_), K(ret));
5694
        } else if (prepare_result.into_exprs_.at(0)->is_obj_access_expr()) {
5695
          const ObObjAccessRawExpr *access_expr = static_cast<const ObObjAccessRawExpr*>(prepare_result.into_exprs_.at(0));
5696
          ObPLDataType type;
5697
          OZ (access_expr->get_final_type(type));
5698
          OZ (static_into.check_into(
5699
            func, current_block_->get_namespace(), prepare_result.is_bulk_));
5700
        } else {
5701
          OZ (static_into.check_into(func, current_block_->get_namespace(), prepare_result.is_bulk_));
5702
        }
5703
      }
5704

5705
      if (OB_SUCC(ret)) {
5706
        if (OB_FAIL(func.add_dependency_objects(prepare_result.ref_objects_))) {
5707
          LOG_WARN("add dependency tables failed", K(ret));
5708
        } else if (OB_FAIL(static_sql.set_ref_objects(prepare_result.ref_objects_))) {
5709
          LOG_WARN("set ref objects failed", K(ret));
5710
        } else {
5711
          // sql contain package var or package udf
5712
          for (int64_t i = 0; OB_SUCC(ret) && i < prepare_result.ref_objects_.count(); ++i) {
5713
            if (DEPENDENCY_PACKAGE == prepare_result.ref_objects_.at(i).object_type_ ||
5714
                DEPENDENCY_PACKAGE_BODY == prepare_result.ref_objects_.at(i).object_type_ ||
5715
                DEPENDENCY_FUNCTION == prepare_result.ref_objects_.at(i).object_type_) {
5716
              func.set_external_state();
5717
            }
5718
          }
5719
          static_sql.set_row_desc(record_type);
5720
        }
5721
      }
5722
    }
5723
  }
5724
  return ret;
5725
}
5726

5727
int ObPLResolver::resolve_sql(const ObStmtNodeTree *parse_tree, ObPLSqlStmt *stmt, ObPLFunctionAST &func)
5728
{
5729
  int ret = OB_SUCCESS;
5730
  CK(OB_NOT_NULL(stmt));
5731
  OZ (resolve_static_sql(parse_tree, *stmt, *stmt, false/*not cursor*/, func));
5732
  OZ (func.get_sql_stmts().push_back(stmt));
5733
  return ret;
5734
}
5735

5736
int ObPLResolver::resolve_using(const ObStmtNodeTree *using_node,
5737
                                ObIArray<InOutParam> &using_params,
5738
                                ObPLFunctionAST &func)
5739
{
5740
  int ret = OB_SUCCESS;
5741
  if (NULL != using_node) {
5742
    ObRawExpr *expr = NULL;
5743
    int64_t out_idx = OB_INVALID_INDEX;
5744
    const ObStmtNodeTree *using_param = NULL;
5745
    ObPLRoutineParamMode using_param_mode = PL_PARAM_INVALID;
5746
    for (int64_t i = 0; OB_SUCC(ret) && i < using_node->num_child_; ++i) {
5747
      out_idx = OB_INVALID_INDEX;
5748
      using_param = using_node->children_[i];
5749
      if (OB_ISNULL(using_param)) {
5750
        ret = OB_ERR_UNEXPECTED;
5751
        LOG_WARN("using param node is NULL", K(i), K(using_node->type_), K(ret));
5752
      } else if (1 != using_param->num_child_) {
5753
        ret = OB_ERR_UNEXPECTED;
5754
        LOG_WARN("using param node must have only 1 child", K(i), K(using_node->type_), K(using_param->num_child_), K(ret));
5755
      } else if (OB_FAIL(resolve_expr(using_param->children_[0], func, expr,
5756
                                   combine_line_and_col(using_param->children_[0]->stmt_loc_)))) {
5757
        LOG_WARN("failed to resolve const", K(ret));
5758
      } else {
5759
        bool legal_extend = false;
5760
        if (ObExtendType == expr->get_result_type().get_type()) {
5761
          if (expr->get_result_type().get_udt_id() != OB_INVALID_ID) {
5762
            const ObUserDefinedType *user_type = NULL;
5763
            CK (OB_NOT_NULL(current_block_));
5764
            OZ (current_block_->get_namespace().get_pl_data_type_by_id(
5765
              expr->get_result_type().get_udt_id(), user_type));
5766
            CK (OB_NOT_NULL(user_type));
5767
            OX (legal_extend = user_type->is_udt_type()
5768
                               || user_type->is_package_type()
5769
                               || user_type->is_sys_refcursor_type()
5770
                               || user_type->is_rowtype_type());
5771
          } else {
5772
            legal_extend = true; // for anonymous collection
5773
          }
5774
        }
5775
        if (OB_SUCC(ret)
5776
            && (T_NULL == using_param->children_[0]->type_
5777
                || ObTinyIntType == expr->get_result_type().get_type()
5778
                || IS_BOOL_OP(using_param->children_[0]->type_)
5779
                || (ObExtendType == expr->get_result_type().get_type() && !legal_extend))) {
5780
          ret = OB_ERR_EXPR_SQL_TYPE;
5781
          LOG_WARN("PLS-00457: expressions have to be of SQL types",
5782
                   K(ret), K(using_param->children_[0]->type_), K(expr->get_result_type()));
5783
        }
5784
        if (OB_SUCC(ret)) {
5785
          switch (using_param->value_) {
5786
          case MODE_IN: {
5787
            using_param_mode = PL_PARAM_IN;
5788
          }
5789
            break;
5790
          case MODE_OUT: { //fallthrough
5791
            using_param_mode = PL_PARAM_OUT;
5792
          }
5793
          case MODE_INOUT: {
5794
            if (MODE_INOUT == using_param->value_) {
5795
              OX (using_param_mode = PL_PARAM_INOUT);
5796
            }
5797
            OZ (resolve_inout_param(expr, using_param_mode, out_idx));
5798
          }
5799
            break;
5800
          default: {
5801
            ret = OB_ERR_UNEXPECTED;
5802
            LOG_WARN("sp inout flag is invalid", K(using_param->value_));
5803
          }
5804
            break;
5805
          }
5806
        }
5807
      }
5808

5809
      OZ (using_params.push_back(InOutParam(func.get_expr_count() - 1, using_param_mode, out_idx)));
5810
    }
5811
  }
5812
  return ret;
5813
}
5814

5815
int ObPLResolver::resolve_execute_immediate(
5816
  const ObStmtNodeTree *parse_tree, ObPLExecuteStmt *stmt, ObPLFunctionAST &func)
5817
{
5818
  int ret = OB_SUCCESS;
5819
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
5820
    ret = OB_INVALID_ARGUMENT;
5821
    LOG_WARN("argument is NULL", K(parse_tree), K(stmt), K(ret));
5822
  } else {
5823
    //解析sql
5824
    ObRawExpr *sql = NULL;
5825
    const ObStmtNodeTree *sql_node = parse_tree->children_[0];
5826
    if (OB_ISNULL(sql_node)) {
5827
      ret = OB_ERR_UNEXPECTED;
5828
      LOG_WARN("sql node is NULL", K(parse_tree->children_), K(sql_node), K(ret));
5829
    } else if (OB_FAIL(resolve_expr(sql_node, func,
5830
                                    sql, combine_line_and_col(sql_node->stmt_loc_)))) {
5831
      LOG_WARN("failed to resolve sql expr", K(ret));
5832
    } else if (!sql->get_result_type().is_string_or_lob_locator_type() && !sql->get_result_type().is_json()
5833
               && !sql->get_result_type().is_geometry()) {
5834
      ret = OB_NOT_SUPPORTED;
5835
      LOG_WARN("dynamic sql must be string type", K(sql->get_result_type()), K(ret));
5836
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "non-string type dynamic sql");
5837
    } else {
5838
      stmt->set_sql(func.get_expr_count() - 1);
5839
    }
5840

5841
    //解析into
5842
    if (OB_SUCC(ret)) {
5843
      const ObStmtNodeTree *into_node = parse_tree->children_[1];
5844
      if (NULL != into_node) {
5845
        if (OB_FAIL(resolve_into(into_node, *stmt, func))) {
5846
          LOG_WARN("type node is NULL", K(parse_tree->children_), K(into_node), K(ret));
5847
        }
5848
      }
5849
    }
5850

5851
    //解析returning into, 语法保证了INTO子句和RETURNING INTO子句不能并存, 因此共用一个INTO结构
5852
    if (OB_SUCC(ret)) {
5853
      const ObStmtNodeTree *returning_node = parse_tree->children_[3];
5854
      if (NULL != returning_node) {
5855
        OZ (resolve_into(returning_node, *stmt, func));
5856
        OX (stmt->set_is_returning(true));
5857
      }
5858
    }
5859

5860
    //解析using
5861
    if (OB_SUCC(ret)) {
5862
      const ObStmtNodeTree *using_node = parse_tree->children_[2];
5863
      if (NULL != using_node) {
5864
        OZ (resolve_using(using_node, stmt->get_using(), func));
5865
        if (OB_FAIL(ret)) {
5866
        } else if (stmt->has_out() && (parse_tree->children_[3] || parse_tree->children_[1])) {
5867
          ret = OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY;
5868
          LOG_WARN("PLS-00254: OUT and IN/OUT modes cannot be used in this context Cause: \
5869
              actual parameter mode (OUT, or IN/OUT) is not used properly in USING clause.\
5870
              For USING clause in an OPEN statement, only IN mode is allowed.", K(ret));
5871
        } else {
5872
          for (int64_t i = 0; OB_SUCC(ret) && i < stmt->get_using().count(); ++i) {
5873
            const ObRawExpr *expr = func.get_expr(stmt->get_using_index(i));
5874
            if (OB_ISNULL(expr)) {
5875
              ret = OB_ERR_UNEXPECTED;
5876
              LOG_WARN("expr is NULL", K(ret));
5877
            } else if (expr->is_obj_access_expr()) {
5878
              pl::ObPLDataType final_type;
5879
              const ObObjAccessRawExpr *access_expr = static_cast<const ObObjAccessRawExpr *>(expr);
5880
              OZ(access_expr->get_final_type(final_type));
5881
              if (OB_SUCC(ret) && final_type.is_type_record() && stmt->is_out(i)) {
5882
                ret =OB_ERR_EXPRESSION_WRONG_TYPE;
5883
                LOG_WARN("expr is wrong type", K(ret));
5884
              }
5885
            }
5886

5887
            if (OB_SUCC(ret) && stmt->is_out(i)) {
5888
              OZ (stmt->generate_into_variable_info(current_block_->get_namespace(), *expr));
5889
            }
5890
          }
5891
        }
5892
      }
5893
    }
5894
  }
5895
  return ret;
5896
}
5897

5898
int ObPLResolver::resolve_extend(const ObStmtNodeTree *parse_tree, ObPLExtendStmt *stmt, ObPLFunctionAST &func)
5899
{
5900
  int ret = OB_SUCCESS;
5901
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
5902
    ret = OB_INVALID_ARGUMENT;
5903
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(ret));
5904
  } else {
5905
    //解析expr
5906
    ObRawExpr *expr = NULL;
5907
    const ObStmtNodeTree *expr_node = parse_tree->children_[0];
5908
    if (OB_ISNULL(expr_node)) {
5909
      ret = OB_ERR_UNEXPECTED;
5910
      LOG_WARN("sql node is NULL", K(parse_tree->children_), K(expr_node), K(ret));
5911
    } else if (OB_FAIL(resolve_expr(expr_node, func,
5912
                                    expr, combine_line_and_col(expr_node->stmt_loc_)))) {
5913
      LOG_WARN("failed to resolve sql expr", K(ret));
5914
    } else if (OB_ISNULL(expr)) {
5915
      ret = OB_ERR_UNEXPECTED;
5916
      LOG_WARN("expr is NULL", K(ret));
5917
    } else if (expr->is_obj_access_expr()) {
5918
      const ObObjAccessRawExpr *access_expr = static_cast<const ObObjAccessRawExpr*>(expr);
5919
      ObPLDataType type;
5920
      if (OB_FAIL(access_expr->get_final_type(type))) {
5921
        LOG_WARN("failed to get final type", K(*access_expr), K(ret));
5922
      } else if (type.is_collection_type()) {
5923
        if (OB_FAIL(type.get_all_depended_user_type(get_resolve_ctx(), get_current_namespace()))) {
5924
          LOG_WARN("get all depended user type failed", K(ret));
5925
        } else {
5926
          stmt->set_extend(func.get_expr_count() - 1);
5927
        }
5928
      } else {
5929
        ret = OB_ERR_UNEXPECTED;
5930
        LOG_WARN("extend method must be used for collcetion type", K(type), K(*expr), K(ret));
5931
      }
5932
    } else {
5933
      ret = OB_ERR_UNEXPECTED;
5934
      LOG_WARN("extend method must be used for collcetion type", K(*expr), K(ret));
5935
    }
5936

5937
    //解析ni
5938
    if (OB_SUCC(ret)) {
5939
      ObRawExpr *n_expr = NULL;
5940
      ObRawExpr *i_expr = NULL;
5941
      int64_t n = OB_INVALID_INDEX;
5942
      int64_t i = OB_INVALID_INDEX;
5943
      if (NULL == parse_tree->children_[1]) {
5944
        ObConstRawExpr *expr = NULL;
5945
        if (OB_FAIL(ObRawExprUtils::build_const_int_expr(expr_factory_, ObIntType, 1, expr))) {
5946
          LOG_WARN("failed to build const expr", K(ret));
5947
        } else if (OB_FAIL(func.add_expr(expr))) {
5948
          LOG_WARN("failed to add expr", K(*expr), K(ret));
5949
        } else {
5950
          n = func.get_expr_count() - 1;
5951
        }
5952
      } else if (T_FUN_SYS != parse_tree->children_[1]->type_
5953
          || NULL == parse_tree->children_[1]->children_[0]
5954
          || T_IDENT != parse_tree->children_[1]->children_[0]->type_
5955
          || 6 != parse_tree->children_[1]->children_[0]->str_len_
5956
          || 0 != STRNCASECMP(parse_tree->children_[1]->children_[0]->str_value_, "EXTEND", 6)) {
5957
        ret = OB_ERR_UNEXPECTED;
5958
        LOG_WARN("Unexpected extend method", K(parse_tree->children_[1]->type_), K(ret));
5959
      } else {
5960
        const ObStmtNodeTree *arg_list = parse_tree->children_[1]->children_[1];
5961
        if (T_EXPR_LIST != arg_list->type_ || 0 == arg_list->num_child_ || arg_list->num_child_ > 2) {
5962
          ret = OB_ERR_UNEXPECTED;
5963
          LOG_WARN("Unexpected extend method", K(arg_list->type_), K(arg_list->num_child_), K(ret));
5964
        } else if (OB_FAIL(resolve_expr(arg_list->children_[0], func, n_expr,
5965
                                        combine_line_and_col(arg_list->children_[0]->stmt_loc_)))) {
5966
          ret = OB_ERR_UNEXPECTED;
5967
          LOG_WARN("Unexpected extend method", K(arg_list->children_[0]->type_), K(ret));
5968
        } else {
5969
          n = func.get_expr_count() - 1;
5970
        }
5971

5972
        if (OB_SUCC(ret) && 2 == arg_list->num_child_) {
5973
          if (OB_FAIL(resolve_expr(arg_list->children_[1], func, i_expr,
5974
                                   combine_line_and_col(arg_list->children_[1]->stmt_loc_)))) {
5975
            ret = OB_ERR_UNEXPECTED;
5976
            LOG_WARN("Unexpected extend method", K(arg_list->children_[1]->type_), K(ret));
5977
          } else {
5978
            i = func.get_expr_count() - 1;
5979
          }
5980
        }
5981
      }
5982

5983
      if (OB_SUCC(ret)) {
5984
        stmt->set_ni(n, i);
5985
      }
5986
    }
5987
  }
5988
  return ret;
5989
}
5990

5991
int ObPLResolver::resolve_udf_pragma(const ObStmtNodeTree *parse_tree,
5992
                                     ObPLFunctionAST &unit_ast)
5993
{
5994
  int ret = OB_SUCCESS;
5995
  CK (OB_NOT_NULL(parse_tree));
5996
  CK (T_SP_PRAGMA_UDF == parse_tree->type_);
5997
  if (OB_SUCC(ret)) {
5998
    if (unit_ast.is_routine()) {
5999
      if (unit_ast.get_compile_flag().compile_with_udf()) {
6000
        ret = OB_ERR_PRAGMA_DECL_TWICE;
6001
        LOG_WARN("PLS-00711: PRAGMA string cannot be declared twice", K(ret));
6002
      } else {
6003
        unit_ast.get_compile_flag().add_udf();
6004
      }
6005
    } else {
6006
      ret = OB_ERR_PRAGMA_ILLEGAL;
6007
      LOG_WARN("PLS-00710: Pragma string cannot be specified here", K(ret));
6008
    }
6009
  }
6010
  return ret;
6011
}
6012

6013
int ObPLResolver::resolve_serially_reusable_pragma(const ObStmtNodeTree *parse_tree,
6014
                                                   ObPLPackageAST &unit_ast)
6015
{
6016
  int ret = OB_SUCCESS;
6017
  CK (OB_NOT_NULL(parse_tree));
6018
  CK (T_SP_PRAGMA_SERIALLY_REUSABLE == parse_tree->type_);
6019
  if (OB_SUCC(ret)) {
6020
    if (unit_ast.is_package()) {
6021
      OX (unit_ast.set_serially_reusable());
6022
    } else {
6023
      ret = OB_ERR_PARAM_IN_PACKAGE_SPEC;
6024
      LOG_WARN("PLS-00708: Pragma string must be declared in a package specification", K(ret));
6025
    }
6026
  }
6027
  return ret;
6028
}
6029

6030
int ObPLResolver::resolve_restrict_references_pragma(const ObStmtNodeTree *parse_tree,
6031
                                                     ObPLPackageAST &ast)
6032
{
6033
  int ret = OB_SUCCESS;
6034
  const ObStmtNodeTree *subprogram_node = NULL;
6035
  const ObStmtNodeTree *assert_list_node = NULL;
6036
  ObString subprogram;
6037
  ObPLCompileFlag compile_flag;
6038
  CK (OB_NOT_NULL(parse_tree));
6039
  CK (T_SP_PRAGMA_RESTRICT_REFERENCE == parse_tree->type_);
6040
  CK (2 == parse_tree->num_child_);
6041
  CK (OB_NOT_NULL(subprogram_node = parse_tree->children_[0]));
6042
  CK (OB_NOT_NULL(assert_list_node = parse_tree->children_[1]));
6043
  if (OB_SUCC(ret) && ast.get_package_type() != ObPackageType::PL_PACKAGE_SPEC) {
6044
    ret = OB_ERR_PARAM_IN_PACKAGE_SPEC;
6045
    LOG_WARN("PLS-00708: Pragma string must be declared in a package specification",
6046
             K(ret), K(ast.get_package_type()));
6047
  }
6048
  // resolve subprogram name
6049
  CK (T_SP_NAME == subprogram_node->type_);
6050
  if (OB_SUCC(ret)) {
6051
    if (0 == subprogram_node->num_child_) {
6052
      // subprogram is empty indicate default, do nothing ...
6053
    } else {
6054
      CK (1 == subprogram_node->num_child_);
6055
      CK (OB_NOT_NULL(subprogram_node->children_[0]));
6056
      CK (T_IDENT == subprogram_node->children_[0]->type_);
6057
      OX (subprogram = ObString(subprogram_node->children_[0]->str_len_,
6058
                                subprogram_node->children_[0]->str_value_));
6059
      if (OB_SUCC(ret) && subprogram.empty()) {
6060
        ret = OB_ERR_IDENT_EMPTY;
6061
        LOG_WARN("Identifier cannot be an empty string", K(ret), K(subprogram));
6062
      }
6063
    }
6064
  }
6065
  // resolve assert list
6066
  if (OB_SUCC(ret)) {
6067
    CK (T_SP_ASSERT_ITEM_LIST == assert_list_node->type_);
6068
    for (int64_t i = 0; OB_SUCC(ret) && i < assert_list_node->num_child_; ++i) {
6069
      ObStmtNodeTree *assert_node = assert_list_node->children_[i];
6070
      CK (OB_NOT_NULL(assert_node));
6071
      CK (T_SP_ASSERT_ITEM == assert_node->type_);
6072
      if (OB_SUCC(ret)
6073
          && !(ObPLCompileFlag::TRUST <= assert_node->value_
6074
               && assert_node->value_ <= ObPLCompileFlag::WNPS)) {
6075
        ObString node(assert_node->str_len_, assert_node->str_value_);
6076
        ret = OB_ERR_PRAGMA_STR_UNSUPPORT;
6077
        LOG_USER_ERROR(OB_ERR_PRAGMA_STR_UNSUPPORT,
6078
                       "RESTRICT_REFERENCES", node.length(), node.ptr());
6079
      }
6080
      OZ (compile_flag.add_compile_flag(assert_node->value_));
6081
    }
6082
  }
6083
  if (OB_SUCC(ret)) {
6084
    if (subprogram.empty() || 0 == subprogram.case_compare(ast.get_name())) {
6085
      OX (ast.set_compile_flag(compile_flag));
6086
    } else {
6087
      ObPLRoutineTable &routine_table = ast.get_routine_table();
6088
      const ObPLRoutineInfo *routine_info = NULL;
6089
      for (int64_t i = routine_table.get_count() - 1; OB_SUCC(ret) && i >= 1; --i) {
6090
        OZ (routine_table.get_routine_info(i, routine_info));
6091
        CK (OB_NOT_NULL(routine_info));
6092
        if (OB_SUCC(ret) && 0 == routine_info->get_name().case_compare(subprogram)) {
6093
          (const_cast<ObPLRoutineInfo*>(routine_info))->set_compile_flag(compile_flag);
6094
          break;
6095
        }
6096
        OX (routine_info = NULL;)
6097
      }
6098
      if (OB_SUCC(ret) && OB_ISNULL(routine_info)) {
6099
        ret = OB_ERR_PRAGMA_FIRST_ARG;
6100
        LOG_USER_ERROR(OB_ERR_PRAGMA_FIRST_ARG, "RESTRICT_REFERENCES");
6101
      }
6102
    }
6103
  }
6104
  return ret;
6105
}
6106

6107
int ObPLResolver::resolve_interface_pragma(const ObStmtNodeTree *parse_tree, ObPLPackageAST &ast)
6108
{
6109
  int ret = OB_SUCCESS;
6110
  const ObStmtNodeTree *name_node = NULL;
6111
  ObString interface_name;
6112
  CK (OB_NOT_NULL(parse_tree));
6113
  CK (T_SP_PRAGMA_INTERFACE == parse_tree->type_);
6114
  CK (1 == parse_tree->num_child_);
6115
  CK (OB_NOT_NULL(name_node = parse_tree->children_[0]));
6116
  if (OB_SUCC(ret)
6117
      && ast.get_package_type() != ObPackageType::PL_PACKAGE_BODY
6118
      && ast.get_package_type() != ObPackageType::PL_UDT_OBJECT_BODY) {
6119
    ret = OB_NOT_SUPPORTED;
6120
    LOG_WARN("Ober Notice: This is not a public feature. Only allowed in package body now",
6121
             K(ret), K(ast.get_package_type()));
6122
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "PRAGMA INTERFACE in package body");
6123
  }
6124
  // resolve interface name
6125
  CK (T_IDENT == name_node->type_);
6126
  if (OB_SUCC(ret)) {
6127
    OX (interface_name = ObString(name_node->str_len_, name_node->str_value_));
6128
    CK (!interface_name.empty());
6129
  }
6130

6131
  if (OB_SUCC(ret)) {
6132
    int64_t idx = OB_INVALID_INDEX;
6133
    ObPLFunctionAST *routine_ast = NULL;
6134
    ObPLRoutineInfo *routine_info = NULL;
6135
    ObPLRoutineTable &routine_table = ast.get_routine_table();
6136
    for (int64_t i = 0;
6137
         OB_SUCC(ret) && OB_INVALID_INDEX == idx && i < routine_table.get_count();
6138
         ++i) {
6139
      //寻找Interface Pragma语句的上一个routine
6140
      routine_ast = NULL;
6141
      routine_info = NULL;
6142
      OZ (routine_table.get_routine_info(i, routine_info));
6143
      OZ (routine_table.get_routine_ast(i, routine_ast));
6144
      if (NULL != routine_info && NULL == routine_ast) {
6145
        //本Interface Pragma修饰的routine一定是只有声明而没有定义的状态
6146
        idx = i;
6147
      }
6148
    }
6149

6150
    if (OB_SUCC(ret)) {
6151
      if (OB_INVALID_INDEX == idx) {
6152
        ret = OB_ERR_UNEXPECTED;
6153
        LOG_WARN(
6154
            "Ober Notice: This is not a public feature. Only allowed follow a routine declare",
6155
            K(interface_name),
6156
            K(ret));
6157
      } else {
6158
        CK(OB_NOT_NULL(routine_info));
6159
        if (OB_SUCC(ret) && OB_NOT_NULL(routine_ast)) {
6160
          ret = OB_ERR_SP_DUP_VAR;
6161
          LOG_USER_ERROR(OB_ERR_SP_DUP_VAR,
6162
              routine_ast->get_name().length(), routine_ast->get_name().ptr());
6163
        }
6164
        OZ (routine_info->add_compile_flag(ast.get_compile_flag()));
6165
        OZ (routine_table.make_routine_ast(resolve_ctx_.allocator_,
6166
                                           ast.get_db_name(),
6167
                                           ast.is_package() ? ast.get_name() : ObString(),
6168
                                           ast.get_version(),
6169
                                           *routine_info,
6170
                                           routine_ast));
6171
        OZ (resolve_routine_block(parse_tree, *routine_info, *routine_ast));
6172
        OZ (routine_table.set_routine_ast(idx, routine_ast));
6173
        OX (ast.set_can_cached(routine_ast->get_can_cached()));
6174
        if (OB_FAIL(ret) && OB_NOT_NULL(routine_ast)) {
6175
          routine_ast->~ObPLFunctionAST();
6176
          resolve_ctx_.allocator_.free(routine_ast);
6177
          routine_ast = NULL;
6178
        }
6179
        OZ (const_cast<ObPLRoutineInfo*>(routine_info)->get_compile_flag().add_intf());
6180
      }
6181
    }
6182
  }
6183
  return ret;
6184
}
6185

6186
int ObPLResolver::resolve_interface(const ObStmtNodeTree *parse_tree,
6187
                                    ObPLInterfaceStmt *stmt,
6188
                                    ObPLFunctionAST &ast)
6189
{
6190
  int ret = OB_SUCCESS;
6191
  const ObStmtNodeTree *name_node = NULL;
6192
  ObString interface_name;
6193
  CK (OB_NOT_NULL(parse_tree));
6194
  CK (T_SP_PRAGMA_INTERFACE == parse_tree->type_);
6195
  CK (1 == parse_tree->num_child_);
6196
  CK (OB_NOT_NULL(name_node = parse_tree->children_[0]));
6197

6198
  // resolve interface name
6199
  CK (T_IDENT == name_node->type_);
6200
  if (OB_SUCC(ret)) {
6201
    OX (interface_name = ObString(name_node->str_len_, name_node->str_value_));
6202
    CK (!interface_name.empty());
6203
  }
6204

6205
  if (OB_SUCC(ret)) {
6206
    PL_C_INTERFACE_t entry = nullptr;
6207
    CK (OB_NOT_NULL(GCTX.pl_engine_));
6208
    OX (entry = GCTX.pl_engine_->get_interface_service().get_entry(interface_name));
6209
    if (OB_SUCC(ret) && OB_ISNULL(entry)) {
6210
      ret = OB_ERR_PRAGMA_FOLLOW_DECL;
6211
      LOG_USER_ERROR(OB_ERR_PRAGMA_FOLLOW_DECL, interface_name.length(), interface_name.ptr());
6212
    }
6213
    OX (stmt->set_entry(interface_name));
6214
    OZ (ast.get_compile_flag().add_intf());
6215
  }
6216
  return ret;
6217
}
6218

6219
int ObPLResolver::resolve_declare_cond(const ObStmtNodeTree *parse_tree,
6220
                                       ObPLPackageAST &package_ast)
6221
{
6222
  int ret = OB_SUCCESS;
6223
  if (OB_FAIL(resolve_declare_cond(parse_tree, NULL, package_ast))) {
6224
    LOG_WARN("failed to resolve declare condition for package", K(ret));
6225
  }
6226
  return ret;
6227
}
6228

6229
int ObPLResolver::resolve_declare_cond(const ObStmtNodeTree *parse_tree,
6230
                                       ObPLDeclareCondStmt *stmt,
6231
                                       ObPLCompileUnitAST &func)
6232
{
6233
  int ret = OB_SUCCESS;
6234
  UNUSED(func);
6235
  UNUSED(stmt);
6236
  if (OB_ISNULL(parse_tree)) {
6237
    ret = OB_INVALID_ARGUMENT;
6238
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(ret));
6239
  } else if (OB_FAIL(check_declare_order(PL_COND))) {
6240
    LOG_WARN("fail to check declare order", K(ret));
6241
  } else {
6242
    //解析name
6243
    const ObStmtNodeTree *name_node = (T_SP_DECL_COND == parse_tree->type_
6244
      ? parse_tree->children_[0] : parse_tree->children_[0]->children_[0]);
6245
    ObString name;
6246
    if (T_IDENT != name_node->type_) {
6247
      ret = OB_ERR_EX_NAME_ARG;
6248
      LOG_WARN("expect a name for exception", K(name_node->type_), K(ret));
6249
    } else if (OB_FAIL(resolve_ident(name_node, name))) {
6250
      LOG_WARN("failed to resolve ident", K(name_node), K(ret));
6251
    }
6252

6253
    //解析condition
6254
    ObPLConditionValue value;
6255
    if (OB_SUCC(ret)) {
6256
      if ((T_SP_DECL_COND == parse_tree->type_ && 2 == parse_tree->num_child_)
6257
          || T_SP_INIT_PRAGMA == parse_tree->type_) {
6258
        // T_SP_DECL_COND is mysql mode
6259
        // T_SP_INIT_PRAGMA is oracle mode
6260
        const ObStmtNodeTree *condition_node = (T_SP_DECL_COND == parse_tree->type_ ?
6261
          parse_tree->children_[1] : NULL);
6262
        if (T_SP_INIT_PRAGMA == parse_tree->type_) {
6263
          if (2 != parse_tree->children_[0]->num_child_) {
6264
            ret = OB_ERR_EX_ARG_NUM;
6265
            LOG_WARN("illegal number of arg", K(parse_tree->children_[0]->num_child_), K(ret));
6266
          } else if (OB_ISNULL(parse_tree->children_[0]->children_[1])) {
6267
            ret = OB_ERR_UNEXPECTED;
6268
            LOG_WARN("param node is NULL", K(ret));
6269
          } else {
6270
            condition_node = parse_tree->children_[0]->children_[1];
6271
          }
6272
        }
6273
        CK (OB_NOT_NULL(condition_node));
6274
        OZ (resolve_condition_value(condition_node, value,
6275
                                    is_sys_database_id(func.get_database_id())));
6276
        OZ (current_block_->get_namespace().add_condition(
6277
              name, value, lib::is_oracle_mode() ? true : false));
6278
      } else { // ORACLE模式下 UserDefinedException
6279
        CK (lib::is_oracle_mode());
6280
        OX (value.type_ = ERROR_CODE);
6281
        // package public or private exception need to combind package id.
6282
        if (OB_FAIL(ret)) {
6283
        } else if (func.is_package()) {
6284
          ObPLPackageAST &pack = static_cast<ObPLPackageAST&>(func);
6285
          OX (value.error_code_
6286
            = (next_user_defined_exception_id_++) | (pack.get_id() << OB_PACKAGE_ID_SHIFT));
6287
        } else {
6288
          OX (value.error_code_ = next_user_defined_exception_id_++);
6289
        }
6290
        OX (value.sql_state_ = ob_sqlstate(static_cast<int>(value.error_code_)));
6291
        OX (value.str_len_ = STRLEN(value.sql_state_));
6292
        OZ (current_block_->get_namespace().add_condition(name, value));
6293
      }
6294
    }
6295
  }
6296
  return ret;
6297
}
6298

6299
int ObPLResolver::resolve_declare_handler(const ObStmtNodeTree *parse_tree, ObPLDeclareHandlerStmt *stmt, ObPLFunctionAST &func)
6300
{
6301
  int ret = OB_SUCCESS;
6302
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt)) {
6303
    ret = OB_INVALID_ARGUMENT;
6304
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(ret));
6305
  } else if (OB_FAIL(check_declare_order(PL_HANDLER))) {
6306
    LOG_WARN("fail to check declare order", K(ret));
6307
  } else {
6308
    ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc* desc =
6309
            static_cast<ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc*>(resolve_ctx_.allocator_.alloc(sizeof(ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc)));
6310
    if (OB_ISNULL(desc)) {
6311
      ret = OB_ALLOCATE_MEMORY_FAILED;
6312
      LOG_WARN("Invalid then node type", K(ret));
6313
    } else {
6314
      desc = new(desc)ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc(resolve_ctx_.allocator_);
6315
      //解析Action
6316
      desc->set_action(static_cast<ObPLDeclareHandlerStmt::DeclareHandler::Action>(parse_tree->value_));
6317

6318
      //解析body：这里必须先解析body后解析condition value，是因为handler的body解析过程不应受本handler自己的in_warning和in_notfound影响
6319
      if (OB_SUCC(ret)) {
6320
        if (OB_ISNULL(parse_tree->children_[1])) {
6321
          ret = OB_ERR_UNEXPECTED;
6322
          LOG_WARN("Invalid body node", K(parse_tree->children_[1]), K(ret));
6323
        } else if (T_SP_PROC_STMT_LIST != parse_tree->children_[1]->type_) {
6324
          ret = OB_ERR_UNEXPECTED;
6325
          LOG_WARN("Invalid else node", K(parse_tree->children_[1]->type_), K(ret));
6326
        } else {
6327
          ObPLStmtBlock *body_block = NULL;
6328
          int64_t top_continue = handler_analyzer_.get_continue();
6329
          ++current_level_;
6330
          if (handler_analyzer_.in_continue()) {
6331
            ObPLDeclareHandlerStmt::DeclareHandler info;
6332
            if (OB_FAIL(handler_analyzer_.get_handler(top_continue, info))) {
6333
              LOG_WARN("failed to get top continue handler", K(ret), K(top_continue));
6334
            } else if (info.get_level() == (current_level_ - 1)) {
6335
              handler_analyzer_.set_continue(OB_INVALID_INDEX);
6336
            }
6337
          }
6338
          if (OB_FAIL(ret)) {
6339
          } else if (OB_FAIL(resolve_stmt_list(parse_tree->children_[1],
6340
                                        body_block,
6341
                                        func,
6342
                                        true,/*stop scarch label*/
6343
                                        true /*in exception handler scope*/))) {
6344
            LOG_WARN("failed to resolve stmt list", K(parse_tree->children_[1]->type_), K(ret));
6345
          } else if (OB_FAIL(handler_analyzer_.reset_handlers(current_level_))) {
6346
            LOG_WARN("failed to reset handlers", K(ret), K(current_level_));
6347
          } else {
6348
            --current_level_;
6349
            handler_analyzer_.reset_notfound_and_warning(current_level_);
6350
            handler_analyzer_.set_continue(top_continue);
6351
            desc->set_body(body_block);
6352
          }
6353
        }
6354
      }
6355

6356
      //解析condition value
6357
      if (OB_SUCC(ret)) {
6358
        const ObStmtNodeTree *handler_list = parse_tree->children_[0];
6359
        if (NULL == handler_list) {
6360
          ret = OB_ERR_UNEXPECTED;
6361
          LOG_WARN("then node is NULL", K(handler_list), K(parse_tree->children_), K(ret));
6362
        } else if (T_SP_HCOND_LIST != handler_list->type_) {
6363
          ret = OB_ERR_UNEXPECTED;
6364
          LOG_WARN("Invalid then node type", K(handler_list->type_), K(ret));
6365
        } else {
6366
          for (int64_t i = 0; OB_SUCC(ret) && i < handler_list->num_child_; ++i) {
6367
            ObPLConditionValue value;
6368
            bool dup = false;
6369
            ObPLConditionType actual_type = INVALID_TYPE;
6370
            if (OB_FAIL(resolve_handler_condition(handler_list->children_[i], value, func))) {
6371
              LOG_WARN("failed to resolve condition value", K(handler_list->children_[i]), K(ret));
6372
            } else if (OB_FAIL(check_duplicate_condition(*stmt, value, dup, desc))) {
6373
              LOG_WARN("failed to check duplication", K(value), K(ret));
6374
            } else if (dup) {
6375
              ret = OB_ERR_SP_DUP_HANDLER;
6376
              LOG_USER_ERROR(OB_ERR_SP_DUP_HANDLER);
6377
              LOG_WARN("Duplicate handler declared in the same block", K(value), K(dup), K(ret));
6378
            } else if (OB_FAIL(ObPLResolver::analyze_actual_condition_type(value, actual_type))) {
6379
              LOG_WARN("failed to analyze actual condition type", K(value), K(ret));
6380
            } else if (lib::is_oracle_mode()
6381
                       && desc->get_conditions().count() > 0
6382
                       && ObPLConditionType::OTHERS
6383
                        == desc->get_conditions().at(desc->get_conditions().count() - 1).type_) {
6384
              ret = OB_ERR_NO_CHOICES;
6385
              LOG_WARN("no choices may appear with choice OTHERS in an exception handler",
6386
                        K(ret));
6387
            } else if (OB_FAIL(desc->add_condition(value))) {
6388
              LOG_WARN("failed to add condition for delcare handler desc", K(ret), K(value));
6389
            } else {
6390
              if (NOT_FOUND == actual_type && !handler_analyzer_.in_notfound()) {
6391
                handler_analyzer_.set_notfound(current_level_);
6392
                current_block_->set_notfound();
6393
              } else if (SQL_WARNING == actual_type && !handler_analyzer_.in_warning()) {
6394
                handler_analyzer_.set_warning(current_level_);
6395
                current_block_->set_warning();
6396
              }
6397
            }
6398
          }
6399
        }
6400
      }
6401
    }
6402

6403
    if (OB_SUCC(ret)) {
6404
      if (desc->is_continue() || handler_analyzer_.in_continue()) {
6405
        //如果自己是continue或者已经在continue里，把自己压栈
6406
        if (OB_FAIL(handler_analyzer_.set_handler(desc, current_level_))) {
6407
          LOG_WARN("failed to set handler", K(ret));
6408
        }
6409
      }
6410
    }
6411
    if (OB_SUCC(ret)) {
6412
      if (desc->is_continue() && !handler_analyzer_.in_continue()) {
6413
        //如果自己是top continue，需要追溯把自己平级的handler都压栈
6414
        handler_analyzer_.set_continue();
6415
        if (OB_FAIL(handler_analyzer_.set_handlers(stmt->get_handlers(), current_level_))) {
6416
          LOG_WARN("failed to set handler", K(ret));
6417
        }
6418
      }
6419
    }
6420

6421
    if (OB_SUCC(ret) && !desc->is_continue()) {
6422
      ObPLDeclareHandlerStmt::DeclareHandler handler;
6423
      handler.set_desc(desc);
6424
      if (OB_FAIL(stmt->add_handler(handler))) {
6425
        LOG_WARN("failed to add handler", K(ret));
6426
      }
6427
    }
6428

6429
    if (OB_SUCC(ret)) {
6430
      if (OB_ISNULL(current_block_)) {
6431
        ret = OB_ERR_UNEXPECTED;
6432
        LOG_WARN("Symbol table is NULL", K(current_block_), K(ret));
6433
      } else if (stmt->get_handlers().count() > 0) {
6434
        current_block_->set_eh(stmt);
6435
      }
6436
    }
6437
  }
6438
  return ret;
6439
}
6440

6441
int ObPLResolver::resolve_resignal(
6442
  const ObStmtNodeTree *parse_tree, ObPLSignalStmt *stmt, ObPLFunctionAST &func)
6443
{
6444
  int ret = OB_SUCCESS;
6445
  UNUSED(func);
6446
  CK (OB_NOT_NULL(parse_tree));
6447
  CK (OB_LIKELY(T_SP_RESIGNAL == parse_tree->type_));
6448
  CK (OB_LIKELY(2 == parse_tree->num_child_));
6449
  CK (OB_NOT_NULL(stmt));
6450
  CK (OB_NOT_NULL(current_block_));
6451
  OX (stmt->set_is_resignal_stmt());
6452
  if (OB_FAIL(ret)) {
6453
  } else if (!current_block_->in_handler()) {
6454
    if (lib::is_oracle_mode()) {
6455
      ret = OB_ERR_SP_COND_MISMATCH;
6456
      LOG_WARN("PLS-00367: a RAISE statement with no exception name must be inside an exception handler", K(ret));
6457
    } else if(OB_NOT_NULL(parse_tree->children_[0]) && OB_FAIL(resolve_signal(parse_tree, stmt, func))) {
6458
      LOG_WARN("resolve resignal fail", K(ret));
6459
    } else {
6460
      ret = OB_ERR_RESIGNAL_WITHOUT_ACTIVE_HANDLER;
6461
      LOG_WARN("RESIGNAL when handler not active", K(ret));
6462
    }
6463
  } else if (OB_ISNULL(parse_tree->children_[0]) && OB_ISNULL(parse_tree->children_[1])) {
6464
    stmt->set_is_signal_null();
6465
  } else {
6466
    OZ (resolve_signal(parse_tree, stmt, func));
6467
  }
6468
  return ret;
6469
}
6470

6471
int ObPLResolver::resolve_signal(const ObStmtNodeTree *parse_tree, ObPLSignalStmt *stmt, ObPLFunctionAST &func)
6472
{
6473
  int ret = OB_SUCCESS;
6474
  UNUSED(func);
6475
  CK (OB_NOT_NULL(parse_tree));
6476
  CK (OB_NOT_NULL(stmt));
6477
  CK (OB_NOT_NULL(current_block_));
6478
  if (OB_SUCC(ret)) {
6479
    //解析 value
6480
    const ObStmtNodeTree *value_node = parse_tree->children_[0];
6481
    if (OB_ISNULL(value_node)) {
6482
      if (lib::is_oracle_mode()) {
6483
        if (OB_SUCC(ret) && !current_block_->in_handler()) {
6484
          ret = OB_ERR_RAISE_NOT_IN_HANDLER;
6485
          LOG_WARN("PLS-00367: a RAISE statement with no exception name must be inside an exception handler", K(ret));
6486
        }
6487
        OX (stmt->set_is_signal_null());
6488
      } else if (!stmt->is_resignal_stmt()) {
6489
        ret = OB_ERR_UNEXPECTED;
6490
        LOG_WARN("signal stmt must specify signal value", K(ret));
6491
      }
6492
    } else if (T_IDENT == value_node->type_ // for mysql mode
6493
               || T_SP_ACCESS_NAME == value_node->type_) { // for oracle mode
6494
      const ObPLConditionValue *value = NULL;
6495
      CK (OB_NOT_NULL(current_block_));
6496
      OZ (resolve_condition(value_node,
6497
                            current_block_->get_namespace(),
6498
                            &value,
6499
                            func));
6500
      if (OB_SUCC(ret) && OB_ISNULL(value)) {
6501
        ret = OB_ERR_SP_COND_MISMATCH;
6502
        LOG_USER_ERROR(OB_ERR_SP_COND_MISMATCH, static_cast<int>(value_node->str_len_), value_node->str_value_);
6503
        LOG_WARN("Undefined CONDITION: condition value is NULL", K(value), K(value_node->str_value_), K(ret));
6504
      }
6505
      if (OB_SUCC(ret)) {
6506
        /*
6507
         * Mysql不允许signal语句的condition是error code类型，只能是sqlstate类型，所以这里禁止掉。
6508
         * If SIGNAL refers to a named condition that is defined with a MySQL error number rather than an SQLSTATE value,
6509
         * a SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE error occurs.
6510
         * */
6511
        if (!lib::is_oracle_mode() && SQL_STATE != value->type_) {
6512
          ret = OB_ERR_SP_BAD_CONDITION_TYPE;
6513
          LOG_WARN("SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE", K(value->type_), K(ret));
6514
        } else if (!is_sqlstate_valid(value->sql_state_, value->str_len_)
6515
            || is_sqlstate_completion(value->sql_state_)) {
6516
          ret = OB_ER_SP_BAD_SQLSTATE;
6517
          LOG_USER_ERROR(OB_ER_SP_BAD_SQLSTATE, static_cast<int>(value->str_len_), value->sql_state_);
6518
          LOG_WARN("Bad SQLSTATE", K(ret));
6519
        } else {
6520
          stmt->set_value(*value);
6521
          stmt->set_ob_error_code(value->error_code_);
6522
        }
6523
      }
6524
    } else if (T_SQL_STATE == value_node->type_) {
6525
      stmt->set_cond_type(SQL_STATE);
6526
      CK (OB_NOT_NULL(value_node->children_[0]));
6527
      CK (OB_LIKELY(T_VARCHAR == value_node->children_[0]->type_));
6528
      if (OB_SUCC(ret)) {
6529
        if (!is_sqlstate_valid(value_node->children_[0]->str_value_, value_node->children_[0]->str_len_)
6530
        || is_sqlstate_completion(value_node->children_[0]->str_value_)) {
6531
          ret = OB_ER_SP_BAD_SQLSTATE;
6532
          LOG_USER_ERROR(OB_ER_SP_BAD_SQLSTATE, static_cast<int>(value_node->children_[0]->str_len_),
6533
                                                value_node->children_[0]->str_value_);
6534
          LOG_WARN("Bad SQLSTATE", K(ret));
6535
        } else {
6536
          stmt->set_sql_state(value_node->children_[0]->str_value_);
6537
          stmt->set_str_len(value_node->children_[0]->str_len_);
6538
        }
6539
      }
6540
    } else {
6541
      ret = OB_ERR_UNEXPECTED;
6542
      LOG_WARN("invalid name node", K(value_node->type_), K(ret));
6543
    }
6544
  }
6545
  if (OB_SUCC(ret) && lib::is_mysql_mode()) {
6546
    const ObStmtNodeTree *info_node = parse_tree->children_[1];
6547
    if (NULL != info_node) {
6548
      CK (T_SP_SIGNAL_INFO_LIST == info_node->type_);
6549
      OZ (stmt->create_item_to_expr_idx(info_node->num_child_));
6550
      for (int64_t i = 0; OB_SUCC(ret) && i < info_node->num_child_; ++i) {
6551
        ObRawExpr *value_expr = NULL;
6552
        ParseNode *var = info_node->children_[i]->children_[0];
6553
        if (T_USER_VARIABLE_IDENTIFIER == var->type_ ||
6554
            T_SYSTEM_VARIABLE == var->type_) {
6555
          ObQualifiedName q_name;
6556
          OZ (ObResolverUtils::resolve_obj_access_ref_node(expr_factory_,
6557
                            var, q_name, resolve_ctx_.session_info_));
6558
          if (T_SYSTEM_VARIABLE == var->type_) {
6559
            q_name.access_idents_.at(0).access_index_ =
6560
                ObSetVar::SET_SCOPE_GLOBAL == static_cast<ObSetVar::SetScopeType>(info_node->children_[i]->value_)
6561
                ? pl::ObPLExternalNS::GLOBAL_VAR : pl::ObPLExternalNS::SESSION_VAR;
6562
          } else if (T_USER_VARIABLE_IDENTIFIER == var->type_) {
6563
            q_name.access_idents_.at(0).access_index_ = pl::ObPLExternalNS::USER_VAR;
6564
          }
6565
          OZ (resolve_var(q_name, func, value_expr, false/*for write*/));
6566
          CK (OB_NOT_NULL(value_expr));
6567
          OZ (func.add_expr(value_expr), value_expr);
6568
        } else {
6569
          OZ (resolve_expr(var,
6570
                          func, value_expr,
6571
                          combine_line_and_col(var->stmt_loc_),
6572
                          true, NULL));
6573
        }
6574
        OZ (stmt->get_item_to_expr_idx().set_refactored(info_node->children_[i]->value_,
6575
                                                        func.get_expr_count() - 1));
6576
        if (OB_HASH_EXIST == ret) {
6577
          ObString item_name;
6578
          switch (info_node->children_[i]->value_)
6579
          {
6580
          case SignalCondInfoItem::DIAG_CLASS_ORIGIN:
6581
            item_name.assign_ptr("CLASS_ORIGIN", static_cast<int32_t>(STRLEN("CLASS_ORIGIN")));
6582
            break;
6583
          case SignalCondInfoItem::DIAG_SUBCLASS_ORIGIN:
6584
            item_name.assign_ptr("SUBCLASS_ORIGIN", static_cast<int32_t>(STRLEN("SUBCLASS_ORIGIN")));
6585
            break;
6586
          case SignalCondInfoItem::DIAG_CONSTRAINT_CATALOG:
6587
            item_name.assign_ptr("CONSTRAINT_CATALOG", static_cast<int32_t>(STRLEN("CONSTRAINT_CATALOG")));
6588
            break;
6589
          case SignalCondInfoItem::DIAG_CONSTRAINT_SCHEMA:
6590
            item_name.assign_ptr("CONSTRAINT_SCHEMA", static_cast<int32_t>(STRLEN("CONSTRAINT_SCHEMA")));
6591
            break;
6592
          case SignalCondInfoItem::DIAG_CONSTRAINT_NAME:
6593
            item_name.assign_ptr("CONSTRAINT_NAME", static_cast<int32_t>(STRLEN("CONSTRAINT_NAME")));
6594
            break;
6595
          case SignalCondInfoItem::DIAG_CATALOG_NAME:
6596
            item_name.assign_ptr("CATALOG_NAME", static_cast<int32_t>(STRLEN("CATALOG_NAME")));
6597
            break;
6598
          case SignalCondInfoItem::DIAG_SCHEMA_NAME:
6599
            item_name.assign_ptr("SCHEMA_NAME", static_cast<int32_t>(STRLEN("SCHEMA_NAME")));
6600
            break;
6601
          case SignalCondInfoItem::DIAG_TABLE_NAME:
6602
            item_name.assign_ptr("TABLE_NAME", static_cast<int32_t>(STRLEN("TABLE_NAME")));
6603
            break;
6604
          case SignalCondInfoItem::DIAG_COLUMN_NAME:
6605
            item_name.assign_ptr("COLUMN_NAME", static_cast<int32_t>(STRLEN("COLUMN_NAME")));
6606
            break;
6607
          case SignalCondInfoItem::DIAG_CURSOR_NAME:
6608
            item_name.assign_ptr("CURSOR_NAME", static_cast<int32_t>(STRLEN("CURSOR_NAME")));
6609
            break;
6610
          case SignalCondInfoItem::DIAG_MESSAGE_TEXT:
6611
            item_name.assign_ptr("MESSAGE_TEXT", static_cast<int32_t>(STRLEN("MESSAGE_TEXT")));
6612
            break;
6613
          case SignalCondInfoItem::DIAG_MYSQL_ERRNO:
6614
            item_name.assign_ptr("MYSQL_ERRNO", static_cast<int32_t>(STRLEN("MYSQL_ERRNO")));
6615
            break;
6616
          default:
6617
            ret = OB_ERR_UNEXPECTED;
6618
            LOG_WARN("signal item is error", K(info_node->children_[i]->value_), K(ret));
6619
            break;
6620
          }
6621
          if (OB_ERR_UNEXPECTED != ret) {
6622
            ret = OB_ERR_DUP_SIGNAL_SET;
6623
            LOG_WARN("duplicate condition information item", K(ret));
6624
            LOG_USER_ERROR(OB_ERR_DUP_SIGNAL_SET, item_name.ptr());
6625
          }
6626
        }
6627
      }
6628
    }
6629
  }
6630
  return ret;
6631
}
6632

6633
int ObPLResolver::resolve_call(const ObStmtNodeTree *parse_tree, ObPLCallStmt *stmt, ObPLFunctionAST &func)
6634
{
6635
  int ret = OB_SUCCESS;
6636
  CK (OB_NOT_NULL(parse_tree));
6637
  CK (OB_NOT_NULL(stmt));
6638
  CK (OB_LIKELY(T_SP_CALL_STMT == parse_tree->type_));
6639
  if (OB_SUCC(ret)) {
6640
    ObSchemaChecker schema_checker;
6641
    ParseNode *name_node = parse_tree->children_[0];
6642
    ParseNode *params_node = parse_tree->children_[1];
6643
    if (OB_ISNULL(name_node)) {
6644
      ret = OB_ERR_UNEXPECTED;
6645
      LOG_WARN("the children of parse tree is NULL", K(name_node), K(ret));
6646
    } else if (OB_FAIL(schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()))) {
6647
      LOG_ERROR("schema checker init failed", K(ret));
6648
    } else {
6649
      ObString db_name;
6650
      ObString package_name;
6651
      ObString sp_name;
6652
      ObArray<ObRawExpr *> expr_params;
6653
      ObString dblink_name;
6654
      if (T_SP_ACCESS_NAME != name_node->type_) {
6655
        ret = OB_ERR_UNEXPECTED;
6656
        LOG_WARN("Invalid procedure name node", K(name_node->type_), K(ret));
6657
      } else if (OB_FAIL(ObResolverUtils::resolve_sp_access_name(schema_checker,
6658
                            resolve_ctx_.session_info_.get_effective_tenant_id(),
6659
                            resolve_ctx_.session_info_.get_database_name(),
6660
                            *name_node, db_name, package_name, sp_name, dblink_name))) {
6661
        LOG_WARN("resolve sp name failed", K(ret));
6662
      }
6663
      if (OB_SUCC(ret) && OB_NOT_NULL(params_node)) {
6664
        CK (T_SP_CPARAM_LIST == params_node->type_ || T_EXPR_LIST == params_node->type_);
6665
        for (int64_t param_idx = 0;
6666
             OB_SUCC(ret) && param_idx < params_node->num_child_; ++param_idx) {
6667
          ObRawExpr *expr = NULL;
6668
          OZ (resolve_expr(params_node->children_[param_idx],
6669
                           static_cast<ObPLCompileUnitAST&>(func), expr,
6670
                           combine_line_and_col(params_node->children_[param_idx]->stmt_loc_),
6671
                           false, NULL));
6672
          CK (OB_NOT_NULL(expr));
6673
          OX (expr_params.push_back(expr));
6674
        }
6675
      }
6676
      if (OB_SUCC(ret)) {
6677
        const ObIRoutineInfo *routine_info = NULL;
6678
        ObProcType routine_type = STANDALONE_PROCEDURE;
6679
        if (OB_FAIL(current_block_->get_namespace().resolve_routine(
6680
                                                            resolve_ctx_,
6681
                                                            db_name,
6682
                                                            package_name,
6683
                                                            sp_name,
6684
                                                            expr_params,
6685
                                                            routine_type,
6686
                                                            routine_info))) {
6687
          LOG_WARN("resolve routine failed", K(ret));
6688
          if (OB_ERR_SP_DOES_NOT_EXIST == ret) {
6689
            LOG_USER_ERROR(OB_ERR_SP_DOES_NOT_EXIST, "PROCEDURE",
6690
                package_name.length(), package_name.ptr(), sp_name.length(), sp_name.ptr());
6691
          }
6692
        } else if (PACKAGE_PROCEDURE == routine_type || PACKAGE_FUNCTION == routine_type) {
6693
          const ObPLRoutineInfo *package_routine_info = static_cast<const ObPLRoutineInfo *>(routine_info);
6694
          stmt->set_proc_id(package_routine_info->get_id());
6695
          stmt->set_package_id(func.get_package_id());
6696
          if (package_routine_info->get_param_count() != 0) {
6697
            if (OB_FAIL(resolve_call_param_list(params_node, package_routine_info->get_params(), stmt, func))) {
6698
              LOG_WARN("failed to resolve call param list", K(ret));
6699
            }
6700
          }
6701
        } else if (STANDALONE_PROCEDURE == routine_type || STANDALONE_FUNCTION == routine_type) {
6702
          const share::schema::ObRoutineInfo *schema_routine_info = static_cast<const ObRoutineInfo *>(routine_info);;
6703
          const common::ObIArray<share::schema::ObRoutineParam*> &routine_params = schema_routine_info->get_routine_params();
6704
          stmt->set_package_id(schema_routine_info->get_package_id());
6705
          if (OB_INVALID_ID == schema_routine_info->get_package_id()) {
6706
            stmt->set_proc_id(schema_routine_info->get_routine_id());
6707
          } else {
6708
            stmt->set_proc_id(schema_routine_info->get_subprogram_id());
6709
          }
6710
          if (routine_params.count() != 0) {
6711
            if (OB_FAIL(resolve_call_param_list(params_node, routine_params, stmt, func))) {
6712
              LOG_WARN("failed to resolve call param list", K(ret));
6713
            }
6714
          }
6715
        } else {}
6716
      }
6717
    }
6718
  }
6719
  return ret;
6720
}
6721

6722
int ObPLResolver::resolve_cparams_expr(const ParseNode *params_node,
6723
                                       ObPLFunctionAST &func,
6724
                                       ObIArray<ObRawExpr*> &exprs)
6725
{
6726
  int ret = OB_SUCCESS;
6727
  CK (OB_NOT_NULL(params_node));
6728
  CK (OB_LIKELY(T_SP_CPARAM_LIST == params_node->type_ || T_EXPR_LIST == params_node->type_));
6729
  for (int64_t i = 0; OB_SUCC(ret) && i < params_node->num_child_; ++i) {
6730
    ObRawExpr *expr = NULL;
6731
    CK (params_node->children_[i]);
6732
    OZ (resolve_expr(params_node->children_[i], static_cast<ObPLCompileUnitAST&>(func), expr,
6733
                     combine_line_and_col(params_node->children_[i]->stmt_loc_), true, NULL));
6734
    CK (OB_NOT_NULL(expr));
6735
    OZ (exprs.push_back(expr));
6736
  }
6737
  return ret;
6738
}
6739

6740
int ObPLResolver::set_write_property(ObRawExpr *raw_expr,
6741
                                     ObRawExprFactory &expr_factory,
6742
                                     const ObSQLSessionInfo *session_info,
6743
                                     ObSchemaGetterGuard *schema_guard,
6744
                                     bool for_write)
6745
{
6746
  int ret = OB_SUCCESS;
6747
  ObObjAccessRawExpr *obj_expr = static_cast<ObObjAccessRawExpr *>(raw_expr);
6748
  ObString func_name;
6749
  CK (OB_NOT_NULL(obj_expr));
6750
  OX (obj_expr->set_write(for_write));
6751
  OZ (build_obj_access_func_name(obj_expr->get_orig_access_idxs(),
6752
                                 expr_factory,
6753
                                 session_info,
6754
                                 schema_guard,
6755
                                 for_write,
6756
                                 func_name));
6757
  OX (obj_expr->set_func_name(func_name));
6758
  OZ (obj_expr->formalize(session_info));
6759
  for (int64_t i = 0; OB_SUCC(ret) && i < obj_expr->get_param_count(); ++i) {
6760
    if (T_FUN_PL_ASSOCIATIVE_INDEX == obj_expr->get_param_expr(i)->get_expr_type()) {
6761
      ObPLAssocIndexRawExpr* index_expr = static_cast<ObPLAssocIndexRawExpr*>(obj_expr->get_param_expr(i));
6762
      CK (OB_NOT_NULL(index_expr));
6763
      OX (index_expr->set_write(for_write));
6764
      if (OB_SUCC(ret) && index_expr->get_param_expr(0)->is_obj_access_expr()) {
6765
        ObObjAccessRawExpr *obj_access_expr = static_cast<ObObjAccessRawExpr*>(index_expr->get_param_expr(0));
6766
        CK (OB_NOT_NULL(obj_access_expr));
6767
        if (obj_access_expr->for_write() != for_write) {
6768
          ObString func_name;
6769
          OX (obj_access_expr->set_write(for_write));
6770
          OZ (build_obj_access_func_name(obj_access_expr->get_orig_access_idxs(),
6771
                                         expr_factory,
6772
                                         session_info,
6773
                                         schema_guard,
6774
                                         for_write,
6775
                                         func_name));
6776
          OX (obj_access_expr->set_func_name(func_name));
6777
          OZ (obj_access_expr->formalize(session_info));
6778
        }
6779
      }
6780
    }
6781
  }
6782
  return ret;
6783
}
6784

6785
int ObPLResolver::resolve_inout_param(ObRawExpr *param_expr, ObPLRoutineParamMode param_mode, int64_t &out_idx)
6786
{
6787
  int ret = OB_SUCCESS;
6788
  out_idx = OB_INVALID_INDEX;
6789
  CK (OB_NOT_NULL(param_expr));
6790

6791
  if (OB_SUCC(ret) && T_SP_CPARAM == param_expr->get_expr_type()) {
6792
    ObCallParamRawExpr *call_expr = static_cast<ObCallParamRawExpr *>(param_expr);
6793
    CK (OB_NOT_NULL(call_expr));
6794
    CK (OB_NOT_NULL(call_expr->get_expr()));
6795
    OX (param_expr = call_expr->get_expr());
6796
  }
6797
  // ObjAccessExpr有几种情况: 本地复杂变量做出参; 本地复杂变量的某个域做出参; Package复杂变量的某个属性做出参;
6798
  if (OB_FAIL(ret)) {
6799
  } else if (param_expr->is_obj_access_expr()) {
6800
    ObObjAccessRawExpr *obj_expr = static_cast<ObObjAccessRawExpr *>(param_expr);
6801
    ObIArray<pl::ObObjAccessIdx>& access_idxs = obj_expr->get_access_idxs();
6802
    //本地复杂变量本身做出参
6803
    if (ObObjAccessIdx::is_local_variable(access_idxs)
6804
        && ObObjAccessIdx::get_local_variable_idx(access_idxs) == (access_idxs.count() - 1)) {
6805
      CK (!obj_expr->get_var_indexs().empty());
6806
      OX (out_idx = obj_expr->get_var_indexs().at(0));
6807
    } else if (ObObjAccessIdx::is_local_variable(access_idxs)
6808
               || ObObjAccessIdx::is_package_variable(access_idxs)
6809
               || ObObjAccessIdx::is_subprogram_variable(access_idxs)) {
6810
      if (ObObjAccessIdx::is_local_variable(access_idxs)) {
6811
        int64_t var_idx
6812
          = access_idxs.at(ObObjAccessIdx::get_local_variable_idx(access_idxs)).var_index_;
6813
        CK (var_idx >= 0 && var_idx < obj_expr->get_var_indexs().count());
6814
        OZ (check_local_variable_read_only(
6815
          current_block_->get_namespace(),
6816
          obj_expr->get_var_indexs().at(var_idx),
6817
          PL_PARAM_INOUT == param_mode),
6818
          K(access_idxs));
6819
      } else {
6820
        OZ (check_variable_accessible(current_block_->get_namespace(), access_idxs, true));
6821
      }
6822
    } else {
6823
      ret = OB_ERR_EXP_NOT_ASSIGNABLE;
6824
      LOG_WARN("expression cannot be used as an assignment", K(ret), K(access_idxs));
6825
    }
6826
    OZ (obj_expr->formalize(&get_resolve_ctx().session_info_));
6827
    OZ (set_write_property(obj_expr, expr_factory_, &resolve_ctx_.session_info_, &resolve_ctx_.schema_guard_, true));
6828
  } else if (param_expr->is_const_raw_expr()) { // 本地变量做出参
6829
    const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(param_expr);
6830
    const ObPLSymbolTable *table = current_block_->get_symbol_table();
6831
    const ObPLVar *var = NULL;
6832
    bool is_anonymos_const_var = false;
6833
    if (!resolve_ctx_.is_prepare_protocol_  &&
6834
        T_QUESTIONMARK == const_expr->get_expr_type() &&
6835
        OB_NOT_NULL(table) &&
6836
        OB_NOT_NULL(var = table->get_symbol(const_expr->get_value().get_unknown())) &&
6837
        0 == var->get_name().case_compare(pl::ObPLResolver::ANONYMOUS_ARG)) {
6838
      is_anonymos_const_var = true;
6839
    }
6840
    if (T_QUESTIONMARK != const_expr->get_expr_type() || is_anonymos_const_var) {
6841
      ret = OB_NOT_SUPPORTED;
6842
      LOG_WARN("procedure parameter expr type is wrong", K(ret), K(const_expr->get_expr_type()));
6843
    } else {
6844
      out_idx = const_expr->get_value().get_unknown();
6845
    }
6846
  } else if (T_OP_GET_USER_VAR == param_expr->get_expr_type() // 用户变量做出参
6847
             || T_OP_GET_SYS_VAR == param_expr->get_expr_type()) {
6848
    // 如果是用户变量和系统变量，是得不到out_index的，退出即可
6849
  } else if (T_OP_GET_PACKAGE_VAR == param_expr->get_expr_type()
6850
             || T_OP_GET_SUBPROGRAM_VAR == param_expr->get_expr_type()) {
6851
    // PACKAGE变量做出参, 得不到OutIDX, 仅检查变量是否可读写
6852
    OZ (check_variable_accessible(param_expr, true));
6853
  } else {
6854
    ret = OB_ERR_EXP_NOT_ASSIGNABLE;
6855
    LOG_WARN("wrong param type with output routine param",
6856
             K(ret), K(param_expr->get_expr_type()), KPC(param_expr));
6857
  }
6858
  if (OB_SUCC(ret) && out_idx != OB_INVALID_INDEX) {
6859
    OZ (check_local_variable_read_only(
6860
      current_block_->get_namespace(), out_idx, PL_PARAM_INOUT == param_mode));
6861
  }
6862
  return ret;
6863
}
6864

6865
int ObPLResolver::check_in_param_type_legal(const ObIRoutineParam *param_info,
6866
                                            const ObRawExpr* param)
6867
{
6868
  int ret = OB_SUCCESS;
6869
  CK (OB_NOT_NULL(param_info));
6870
  CK (OB_NOT_NULL(param));
6871
  if (OB_SUCC(ret)) {
6872
    ObPLDataType expected_type, actually_type;
6873
    if (param->is_obj_access_expr()) {
6874
      const ObObjAccessRawExpr *obj_access = NULL;
6875
      CK (OB_NOT_NULL(obj_access = static_cast<const ObObjAccessRawExpr*>(param)));
6876
      OZ (obj_access->get_final_type(actually_type));
6877
    } else if (T_QUESTIONMARK == param->get_expr_type()) {
6878
      int64_t var_idx = OB_INVALID_INDEX;
6879
      const ObPLVar *var = NULL;
6880
      CK (OB_NOT_NULL(current_block_));
6881
      OX (var_idx = static_cast<const ObConstRawExpr*>(param)->get_value().get_unknown());
6882
      CK (OB_NOT_NULL(var = current_block_->get_variable(var_idx)));
6883
      OX (actually_type = var->get_pl_data_type());
6884
    } else if (param->has_flag(IS_PL_MOCK_DEFAULT_EXPR)) {
6885
      new(&actually_type)ObPLDataType(ObNullType);
6886
    } else {
6887
      new(&actually_type)ObPLDataType(param->get_data_type());
6888
      actually_type.get_data_type()->set_udt_id(param->get_result_type().get_udt_id());
6889
    }
6890
    if (OB_SUCC(ret)) {
6891
      if (param_info->is_schema_routine_param()) {
6892
        const ObRoutineParam* iparam = static_cast<const ObRoutineParam*>(param_info);
6893
        if (ObParamExternType::SP_EXTERN_DBLINK == iparam->get_extern_type_flag()) {
6894
          const ObUserDefinedType *udt = NULL;
6895
          CK (iparam->get_extended_type_info().count() > 0);
6896
          OZ (resolve_ctx_.package_guard_.dblink_guard_.get_dblink_type_by_name(
6897
              iparam->get_type_owner(), iparam->get_extended_type_info().at(0),
6898
              iparam->get_type_subname(), iparam->get_type_name(), udt));
6899
          CK (OB_NOT_NULL(udt));
6900
          OX (expected_type.set_user_type_id(udt->get_type(), udt->get_user_type_id()));
6901
          OX (expected_type.set_type_from(ObPLTypeFrom::PL_TYPE_DBLINK));
6902
          OZ (expected_type.set_type_info(iparam->get_extended_type_info()));
6903
        } else {
6904
          OZ (pl::ObPLDataType::transform_from_iparam(iparam,
6905
                                                      resolve_ctx_.schema_guard_,
6906
                                                      resolve_ctx_.session_info_,
6907
                                                      resolve_ctx_.allocator_,
6908
                                                      resolve_ctx_.sql_proxy_,
6909
                                                      expected_type));
6910
        }
6911
      } else {
6912
        const ObPLRoutineParam* iparam = static_cast<const ObPLRoutineParam*>(param_info);
6913
        OX (expected_type = iparam->get_type());
6914
      }
6915
    }
6916
    if (OB_SUCC(ret) && !(actually_type == expected_type)) {
6917
      bool is_legal = true;
6918
      if (actually_type.is_cursor_type() && expected_type.is_cursor_type()) {
6919
        // do nothing ...
6920
      } else if (actually_type.is_obj_type() && ObNullType == actually_type.get_obj_type()) {
6921
        // do nothing ...
6922
      } else if (actually_type.is_composite_type() && expected_type.is_composite_type()) {
6923
        uint64_t actual_udt_id = actually_type.get_user_type_id();
6924
        if ((OB_INVALID_ID == actual_udt_id || OB_INVALID_ID == extract_package_id(actual_udt_id)) &&
6925
            resolve_ctx_.is_prepare_protocol_ &&
6926
            actually_type.is_collection_type() &&
6927
            OB_NOT_NULL(resolve_ctx_.params_.param_list_) &&
6928
            T_QUESTIONMARK == param->get_expr_type()) { // anony array
6929
          int64_t index = static_cast<const ObConstRawExpr*>(param)->get_value().get_unknown();
6930
          CK (resolve_ctx_.params_.param_list_->count() > index);
6931
          if (OB_SUCC(ret)) {
6932
            const ObObjParam &param = resolve_ctx_.params_.param_list_->at(index);
6933
            const pl::ObPLComposite *src_composite = NULL;
6934
            const pl::ObPLCollection *src_coll = NULL;
6935
            const pl::ObUserDefinedType *pl_user_type = NULL;
6936
            const pl::ObCollectionType *coll_type = NULL;
6937
            CK (OB_NOT_NULL(src_composite = reinterpret_cast<const ObPLComposite *>(param.get_ext())));
6938
            OZ (resolve_ctx_.get_user_type(expected_type.get_user_type_id(), pl_user_type));
6939
            CK (OB_NOT_NULL(coll_type = static_cast<const ObCollectionType *>(pl_user_type)));
6940
            CK (OB_NOT_NULL(src_coll = static_cast<const ObPLCollection *>(src_composite)));
6941
            if (OB_FAIL(ret)) {
6942
            } else if (coll_type->get_element_type().is_obj_type() ^
6943
                      src_coll->get_element_desc().is_obj_type()) {
6944
              ret = OB_INVALID_ARGUMENT;
6945
              LOG_WARN("incorrect argument type, diff type",
6946
                            K(ret), K(coll_type->get_element_type()), K(src_coll->get_element_desc()));
6947
            } else if (coll_type->get_element_type().is_obj_type()) { // basic data type
6948
              const ObDataType *src_data_type = &src_coll->get_element_desc();
6949
              const ObDataType *dst_data_type = coll_type->get_element_type().get_data_type();
6950
              if (dst_data_type->get_obj_type() == src_data_type->get_obj_type()) {
6951
                // do nothing
6952
              } else if (cast_supported(src_data_type->get_obj_type(),
6953
                                        src_data_type->get_collation_type(),
6954
                                        dst_data_type->get_obj_type(),
6955
                                        dst_data_type->get_collation_type())) {
6956
                // do nothing
6957
              } else {
6958
                ret = OB_INVALID_ARGUMENT;
6959
                LOG_WARN("incorrect argument type, diff type", K(ret));
6960
              }
6961
            } else {
6962
              // element is composite type
6963
              uint64_t element_type_id = src_coll->get_element_desc().get_udt_id();
6964
              is_legal = element_type_id == coll_type->get_element_type().get_user_type_id();
6965
              if (!is_legal) {
6966
                OZ (ObPLResolver::check_composite_compatible(
6967
                  NULL == resolve_ctx_.params_.secondary_namespace_
6968
                      ? static_cast<const ObPLINS&>(resolve_ctx_)
6969
                      : static_cast<const ObPLINS&>(*resolve_ctx_.params_.secondary_namespace_),
6970
                  element_type_id, coll_type->get_element_type().get_user_type_id(), is_legal));
6971
              }
6972
            }
6973
          } else {
6974
            if (actual_udt_id != expected_type.get_user_type_id()) {
6975
              OZ (check_composite_compatible(current_block_->get_namespace(),
6976
                                            actual_udt_id,
6977
                                            expected_type.get_user_type_id(),
6978
                                            is_legal));
6979
            }
6980
          }
6981
        }
6982
      } else if (actually_type.is_composite_type() || expected_type.is_composite_type()) {
6983
        if (actually_type.is_obj_type()
6984
             && ObExtendType == actually_type.get_data_type()->get_obj_type()) {
6985
          is_legal =
6986
              actually_type.get_data_type()->get_udt_id() == expected_type.get_user_type_id();
6987
        } else if (expected_type.is_obj_type()
6988
                    && ObExtendType == expected_type.get_data_type()->get_obj_type()) {
6989
          is_legal =
6990
            expected_type.get_data_type()->get_udt_id() == actually_type.get_user_type_id();
6991
        } else {
6992
          is_legal = false;
6993
        }
6994
      } else { /*do nothing*/ }
6995
      if (OB_SUCC(ret) && !is_legal) {
6996
        ret = OB_ERR_WRONG_TYPE_FOR_VAR;
6997
        LOG_WARN("PLS-00306: wrong number or types of arguments in call stmt",
6998
                 K(ret), K(actually_type), K(expected_type));
6999
      }
7000
    }
7001
  }
7002
  return ret;
7003
}
7004

7005
int ObPLResolver::resolve_cparam_without_assign(ObRawExpr* expr,
7006
                                                const int64_t position,
7007
                                                ObPLFunctionAST &func,
7008
                                                ObIArray<ObRawExpr*> &params,
7009
                                                ObIArray<int64_t> &expr_idxs)
7010
{
7011
  int ret = OB_SUCCESS;
7012
  int64_t expr_idx = OB_INVALID_INDEX;
7013
  CK (OB_NOT_NULL(expr));
7014
  CK (OB_LIKELY(expr_idxs.count() == params.count()));
7015
  CK (OB_LIKELY(position >= 0 && position < params.count()));
7016
  CK (OB_ISNULL(params.at(position)));
7017
  if (OB_SUCC(ret)) {
7018
    if (T_SP_CPARAM == expr->get_expr_type()) {
7019
      ObCallParamRawExpr* call_expr = static_cast<ObCallParamRawExpr*>(expr);
7020
      CK (OB_NOT_NULL(call_expr));
7021
      CK (OB_NOT_NULL(call_expr->get_expr()));
7022
      CK (has_exist_in_array(func.get_exprs(), call_expr->get_expr(), &expr_idx));
7023
    } else {
7024
      OV (has_exist_in_array(func.get_exprs(), expr, &expr_idx), OB_ERR_UNEXPECTED, KPC(expr));
7025
    }
7026
  }
7027
  CK (OB_LIKELY(expr_idx != OB_INVALID_INDEX));
7028
  OX (expr_idxs.at(position) = expr_idx);
7029
  OX (params.at(position) = expr);
7030
  return ret;
7031
}
7032

7033
int ObPLResolver::resolve_cparam_with_assign(ObRawExpr* expr,
7034
                                             const common::ObIArray<ObIRoutineParam*> &params_list,
7035
                                             ObPLFunctionAST &func,
7036
                                             ObIArray<ObRawExpr*> &params,
7037
                                             ObIArray<int64_t> &expr_idx)
7038
{
7039
  int ret = OB_SUCCESS;
7040
  CK (OB_NOT_NULL(expr));
7041
  CK (OB_LIKELY(T_SP_CPARAM == expr->get_expr_type()));
7042
  if (OB_SUCC(ret)) {
7043
    ObString name;
7044
    int64_t position = -1;
7045
    ObCallParamRawExpr* call_expr = static_cast<ObCallParamRawExpr*>(expr);
7046
    CK (OB_NOT_NULL(call_expr));
7047
    CK (!call_expr->get_name().empty());
7048
    OX (name = call_expr->get_name());
7049
    for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7050
      if (0 == params_list.at(i)->get_name().case_compare(name)) {
7051
        position = i;
7052
        break;
7053
      }
7054
    }
7055
    if (OB_SUCC(ret) && -1 == position) {
7056
      ret = OB_ERR_SP_UNDECLARED_VAR;
7057
      LOG_WARN("can not find param in param list", K(ret), K(position), K(name));
7058
    }
7059
    OZ (resolve_cparam_without_assign(call_expr->get_expr(), position, func, params, expr_idx));
7060
  }
7061
  return ret;
7062
}
7063

7064
int ObPLResolver::resolve_nocopy_params(const ObIRoutineInfo *routine_info,
7065
                                        ObUDFInfo &udf_info)
7066
{
7067
  int ret = OB_SUCCESS;
7068
  ObSEArray<const ObRawExpr*, 16> actual_params_list;
7069
  ObSEArray<ObIRoutineParam*, 16> formal_params_list;
7070
  ObUDFRawExpr *udf_raw_expr = udf_info.ref_expr_;
7071
  CK (OB_NOT_NULL(routine_info));
7072
  CK (OB_NOT_NULL(udf_raw_expr));
7073
  for (int64_t i = 0; OB_SUCC(ret) && i < routine_info->get_param_count(); ++i) {
7074
    ObIRoutineParam* param = NULL;
7075
    OZ (routine_info->get_routine_param(i, param));
7076
    CK (OB_NOT_NULL(param));
7077
    OZ (formal_params_list.push_back(param));
7078
  }
7079
  CK (udf_raw_expr->get_param_count() == formal_params_list.count());
7080
  for (int64_t i = 0; OB_SUCC(ret) && i < formal_params_list.count(); ++i) {
7081
    CK (OB_NOT_NULL(udf_raw_expr->get_param_expr(i)));
7082
    OZ (actual_params_list.push_back(udf_raw_expr->get_param_expr(i)));
7083
  }
7084
  OZ (resolve_nocopy_params(formal_params_list,
7085
                            actual_params_list,
7086
                            udf_raw_expr->get_nocopy_params()));
7087
  return ret;
7088
}
7089

7090
int ObPLResolver::resolve_nocopy_params(const ObIArray<ObIRoutineParam *> &formal_param_list,
7091
                                        ObPLCallStmt *call_stmt)
7092
{
7093
  int ret = OB_SUCCESS;
7094
  ObSEArray<const ObRawExpr*, 16> actual_params_list;
7095
  for (int64_t i = 0; OB_SUCC(ret) && i < formal_param_list.count(); ++i) {
7096
    OZ (actual_params_list.push_back(call_stmt->get_param_expr(i)));
7097
  }
7098
  OZ (resolve_nocopy_params(formal_param_list,
7099
                            actual_params_list,
7100
                            call_stmt->get_nocopy_params()));
7101
  return ret;
7102
}
7103

7104
int ObPLResolver::resolve_nocopy_params(const ObIArray<ObIRoutineParam *> &formal_params_list,
7105
                                        const ObIArray<const ObRawExpr *> &actual_params_list,
7106
                                        ObIArray<int64_t> &nocopy_params)
7107
{
7108
  int ret = OB_SUCCESS;
7109
  CK (formal_params_list.count() == actual_params_list.count());
7110
  for (int64_t i = 0; OB_SUCC(ret) && i < formal_params_list.count(); ++i) {
7111
    nocopy_params.push_back(OB_INVALID_INDEX);
7112
  }
7113
  for (int64_t i = 0; OB_SUCC(ret) && i < formal_params_list.count(); ++i) {
7114
    ObIRoutineParam* formal_param = formal_params_list.at(i);
7115
    pl::ObPLDataType pl_type = formal_param->get_pl_data_type();
7116
    if (formal_param->is_nocopy_param()
7117
        && pl_type.is_obj_type()
7118
        && *(pl_type.get_meta_type()) == (actual_params_list.at(i)->get_result_type())) {
7119
      nocopy_params.at(i) = i;
7120
      for (int64_t j = 0; OB_SUCC(ret) && j < i; ++j) {
7121
        ObIRoutineParam *formal_param = formal_params_list.at(j);
7122
        pl::ObPLDataType tmp_pl_type = formal_param->get_pl_data_type();
7123
        if (tmp_pl_type.is_obj_type()
7124
            && *(pl_type.get_meta_type()) == *(tmp_pl_type.get_meta_type())
7125
            && actual_params_list.at(i)->same_as(*(actual_params_list.at(j)))
7126
            && (formal_param->is_in_param() || formal_param->is_nocopy_param())) {
7127
            nocopy_params.at(j) = i;
7128
        }
7129
      }
7130
    }
7131
  }
7132
  return ret;
7133
}
7134

7135
int ObPLResolver::resolve_cparams(ObIArray<ObRawExpr*> &exprs,
7136
                                  const common::ObIArray<ObIRoutineParam*> &params_list,
7137
                                  ObPLStmt *stmt,
7138
                                  ObPLFunctionAST &func)
7139
{
7140
  int ret = OB_SUCCESS;
7141
  CK (OB_NOT_NULL(stmt));
7142
  ObSEArray<ObRawExpr*, 32> params;
7143
  ObSEArray<int64_t, 32> expr_idx;
7144
  // Step 1: CHECK, input exprs count must be less than params_list.
7145
  if (exprs.count() > params_list.count()) {
7146
    ret = OB_ERR_SP_WRONG_ARG_NUM;
7147
    LOG_WARN("routine param does not has default value",
7148
              K(ret), K(exprs.count()), K(params_list.count()));
7149
  }
7150
  // Step 2: initilize params array, put all null.
7151
  for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7152
    OZ (params.push_back(NULL));
7153
    OZ (expr_idx.push_back(OB_INVALID_INDEX));
7154
  }
7155
  // Step 3: resolve exprs, put actully param to right position.
7156
  bool has_assign_param = false;
7157
  for (int64_t i = 0; OB_SUCC(ret) && i < exprs.count(); ++i) {
7158
    if (OB_ISNULL(exprs.at(i))) {
7159
      ret = OB_ERR_UNEXPECTED;
7160
      LOG_WARN("param node is NULL", K(i), K(ret));
7161
    } else if (T_SP_CPARAM == exprs.at(i)->get_expr_type()) {
7162
      has_assign_param = true;
7163
      OZ (resolve_cparam_with_assign(exprs.at(i), params_list, func, params, expr_idx));
7164
    } else if (has_assign_param) {
7165
      ret = OB_ERR_UNEXPECTED;
7166
      LOG_WARN("can not set param without assign after param with assign", K(ret));
7167
    } else {
7168
      OZ (resolve_cparam_without_assign(exprs.at(i), i, func, params, expr_idx));
7169
    }
7170
  }
7171
  // Step 4: process vacancy parameter, fill default expr otherwise report error.
7172
  for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
7173
    ObIRoutineParam *formal_param = params_list.at(i);
7174
    if (OB_ISNULL(params.at(i))) { // 空缺参数
7175
      if (OB_ISNULL(formal_param)) {
7176
        ret = OB_ERR_UNEXPECTED;
7177
        LOG_WARN("routine param is null", K(ret), K(i));
7178
      } else {
7179
        if (PL_CALL == stmt->get_type()) {
7180
          if (formal_param->get_default_value().empty()) {
7181
            ret = OB_ERR_SP_WRONG_ARG_NUM;
7182
            LOG_WARN("routine param does not has default value",
7183
                     K(ret), K(i), K(formal_param->get_default_value()), K(exprs.count()));
7184
          } else {
7185
            ObConstRawExpr *default_expr = NULL;
7186
            OZ (ObRawExprUtils::build_const_int_expr(expr_factory_, ObIntType, 0, default_expr));
7187
            CK (OB_NOT_NULL(default_expr));
7188
            OZ (default_expr->add_flag(IS_PL_MOCK_DEFAULT_EXPR));
7189
            OZ (func.add_expr(default_expr));
7190
            OZ (resolve_cparam_without_assign(default_expr, i, func, params, expr_idx));
7191
          }
7192
        } else if (PL_OPEN == stmt->get_type()
7193
                   || PL_OPEN_FOR == stmt->get_type()
7194
                   || PL_CURSOR_FOR_LOOP == stmt->get_type()) {
7195
          int64_t default_idx = static_cast<ObPLVar *>(formal_param)->get_default();
7196
          if (OB_UNLIKELY(-1 == default_idx)) {
7197
            ret = OB_ERR_SP_WRONG_ARG_NUM;
7198
            LOG_WARN("actual param expr is null", KPC(formal_param), KPC(static_cast<ObPLVar *>(formal_param)), K(ret));
7199
          } else {
7200
            ObConstRawExpr *default_expr = NULL;
7201
            OZ (ObRawExprUtils::build_const_int_expr(expr_factory_, ObIntType, default_idx, default_expr));
7202
            CK (OB_NOT_NULL(default_expr));
7203
            OZ (default_expr->add_flag(IS_PL_MOCK_DEFAULT_EXPR));
7204
            OZ (func.add_expr(default_expr));
7205
            OZ (resolve_cparam_without_assign(default_expr, i, func, params, expr_idx));
7206
          }
7207
        } else {
7208
          ret = OB_ERR_UNEXPECTED;
7209
          LOG_WARN("params using in invalid stmt", K(stmt->get_type()), K(ret));
7210
        }
7211
      }
7212
    } else if (stmt->get_type() != PL_CALL) { // for cursor, need to add convert to param expr
7213
      int64_t idx = OB_INVALID_INDEX;
7214
      CK (PL_CURSOR_FOR_LOOP == stmt->get_type() || PL_OPEN == stmt->get_type());
7215
      CK (OB_NOT_NULL(formal_param));
7216
      OZ (convert_cursor_actual_params(
7217
        params.at(i), formal_param->get_pl_data_type(), func, idx));
7218
      if (OB_SUCC(ret) && idx != OB_INVALID_INDEX) {
7219
        expr_idx.at(i) = idx;
7220
      }
7221
    }
7222
  }
7223
  // Step 5: add params to stmt.
7224
  if (OB_SUCC(ret)) {
7225
    if (PL_CALL == stmt->get_type()) {
7226
      for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
7227
        const ObIRoutineParam* param_info = params_list.at(i);
7228
        ObPLRoutineParamMode param_mode = PL_PARAM_INVALID;
7229
        int64_t out_idx = OB_INVALID_INDEX;
7230
        CK (OB_NOT_NULL(param_info));
7231
        OX (param_mode = static_cast<ObPLRoutineParamMode>(param_info->get_mode()));
7232
        CK (param_mode != PL_PARAM_INVALID);
7233
        CK (OB_NOT_NULL(params.at(i)));
7234
        if (OB_SUCC(ret)
7235
            && (PL_PARAM_INOUT == param_mode || PL_PARAM_OUT == param_mode)) {
7236
          OZ (resolve_inout_param(params.at(i), param_mode, out_idx), K(i), K(params), K(exprs));
7237
        }
7238
        if (OB_SUCC(ret)
7239
            && OB_LIKELY(OB_INVALID_INDEX != expr_idx.at(i))) {
7240
          OZ (static_cast<ObPLCallStmt*>(stmt)->add_param(expr_idx.at(i), param_mode, out_idx));
7241
        }
7242
      }
7243
      OZ (resolve_nocopy_params(params_list, static_cast<ObPLCallStmt*>(stmt)));
7244
    } else if (PL_CURSOR_FOR_LOOP == stmt->get_type()) {
7245
      OZ (static_cast<ObPLCursorForLoopStmt*>(stmt)->set_params(expr_idx));
7246
    } else { //must be Open Stmt
7247
      OZ (static_cast<ObPLOpenStmt*>(stmt)->set_params(expr_idx));
7248
    }
7249
  }
7250
  // Step 6: check input parameter legal
7251
  if (OB_SUCC(ret) && PL_CALL == stmt->get_type()) {
7252
    for (int64_t i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
7253
      OZ (check_in_param_type_legal(params_list.at(i), params.at(i)));
7254
    }
7255
  }
7256
  return ret;
7257
}
7258

7259
int ObPLResolver::resolve_call_param_list(ObIArray<ObRawExpr*> &params,
7260
                                          const common::ObIArray<ObPLRoutineParam *> &params_list,
7261
                                          ObPLCallStmt *stmt,
7262
                                          ObPLFunctionAST &func)
7263
{
7264
  int ret = OB_SUCCESS;
7265
  ObSEArray<ObIRoutineParam*, 16> iparams;
7266
  CK (OB_NOT_NULL(stmt));
7267
  for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7268
    OZ (iparams.push_back(params_list.at(i)));
7269
  }
7270
  OZ (resolve_cparams(params, iparams, stmt, func));
7271
  return ret;
7272
}
7273

7274
int ObPLResolver::resolve_call_param_list(ObIArray<ObRawExpr*> &params,
7275
                                          const ObIArray<ObRoutineParam*> &params_list,
7276
                                          ObPLCallStmt *stmt,
7277
                                          ObPLFunctionAST &func)
7278
{
7279
  int ret = OB_SUCCESS;
7280
  ObSEArray<ObIRoutineParam*, 16> iparams;
7281
  CK (OB_NOT_NULL(stmt));
7282
  for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7283
    OZ (iparams.push_back(params_list.at(i)));
7284
  }
7285
  OZ (resolve_cparams(params, iparams, stmt, func));
7286
  return ret;
7287
}
7288

7289
int ObPLResolver::resolve_call_param_list(const ObStmtNodeTree *parse_tree,
7290
                                          const common::ObIArray<ObPLRoutineParam *> &params_list,
7291
                                          ObPLCallStmt *stmt,
7292
                                          ObPLFunctionAST &func)
7293
{
7294
  int ret = OB_SUCCESS;
7295
  ObSEArray<ObRawExpr*, 32> exprs;
7296
  ObSEArray<ObIRoutineParam*, 16> iparams;
7297
  CK (OB_NOT_NULL(stmt));
7298
  CK (OB_NOT_NULL(parse_tree));
7299
  OZ (resolve_cparams_expr(parse_tree, func, exprs));
7300
  for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7301
    OZ (iparams.push_back(params_list.at(i)));
7302
  }
7303
  OZ (resolve_cparams(exprs, iparams, stmt, func));
7304
  return ret;
7305
}
7306

7307
int ObPLResolver::resolve_call_param_list(const ObStmtNodeTree *parse_tree,
7308
                                          const ObIArray<ObRoutineParam*> &params_list,
7309
                                          ObPLCallStmt *stmt,
7310
                                          ObPLFunctionAST &func)
7311
{
7312
  int ret = OB_SUCCESS;
7313
  ObSEArray<ObRawExpr*, 32> exprs;
7314
  ObSEArray<ObIRoutineParam*, 16> iparams;
7315
  CK (OB_NOT_NULL(stmt));
7316
  CK (OB_NOT_NULL(parse_tree));
7317
  OZ (resolve_cparams_expr(parse_tree, func, exprs));
7318
  for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
7319
    OZ (iparams.push_back(params_list.at(i)));
7320
  }
7321
  OZ (resolve_cparams(exprs, iparams, stmt, func));
7322
  return ret;
7323
}
7324

7325
int ObPLResolver::check_cursor_formal_params(
7326
  const ObIArray<int64_t>& formal_params, ObPLCursor &cursor, bool &legal)
7327
{
7328
  int ret = OB_SUCCESS;
7329

7330
  const ObPLSymbolTable *left_symbol_table = NULL;
7331
  const ObPLSymbolTable *right_symbol_table = NULL;
7332
  const ObIArray<ObRawExpr *> *left_expr_table = NULL;
7333
  const ObIArray<ObRawExpr *> *right_expr_table = NULL;
7334
  OX (legal = true);
7335
  CK (OB_NOT_NULL(current_block_));
7336
  CK (OB_NOT_NULL(left_symbol_table = current_block_->get_namespace().get_symbol_table()));
7337
  CK (OB_NOT_NULL(left_expr_table = current_block_->get_namespace().get_exprs()));
7338
  if (OB_FAIL(ret)) {
7339
  } else if (formal_params.count() != cursor.get_formal_params().count()) {
7340
    legal = false;
7341
  } else if (cursor.get_package_id() != current_block_->get_namespace().get_package_id()
7342
      || cursor.get_routine_id() != current_block_->get_namespace().get_routine_id()) {
7343
    // external cursor
7344
    CK (OB_NOT_NULL(current_block_->get_namespace().get_external_ns()));
7345
    CK (OB_NOT_NULL(current_block_->get_namespace().get_external_ns()->get_parent_ns()));
7346
    CK (OB_NOT_NULL(right_symbol_table
7347
      = current_block_->get_namespace().get_external_ns()->get_parent_ns()->get_symbol_table()));
7348
    CK (OB_NOT_NULL(right_expr_table
7349
      = current_block_->get_namespace().get_external_ns()->get_parent_ns()->get_exprs()));
7350
  } else {
7351
    // local cursor
7352
    CK (OB_NOT_NULL(right_symbol_table = left_symbol_table));
7353
    CK (OB_NOT_NULL(right_expr_table = left_expr_table));
7354
  }
7355
  for (int64_t i = 0; OB_SUCC(ret) && legal && i < formal_params.count(); ++i) {
7356
    const ObPLVar* left_var = left_symbol_table->get_symbol(formal_params.at(i));
7357
    const ObPLVar* right_var = right_symbol_table->get_symbol(cursor.get_formal_params().at(i));
7358
    const ObRawExpr *left_default_expr = NULL;
7359
    const ObRawExpr *right_default_expr = NULL;
7360
    CK (OB_NOT_NULL(left_var));
7361
    CK (OB_NOT_NULL(right_var));
7362
    CK ((-1 == left_var->get_default()) || (left_var->get_default() < left_expr_table->count()));
7363
    CK ((-1 == right_var->get_default()) || (right_var->get_default() < right_expr_table->count()));
7364
    OX (left_default_expr
7365
      = (-1 == left_var->get_default()) ? NULL : left_expr_table->at(left_var->get_default()));
7366
    OX (right_default_expr
7367
      = (-1 == right_var->get_default()) ? NULL : right_expr_table->at(right_var->get_default()));
7368
    if (OB_FAIL(ret)) {
7369
    } else if (left_var->get_name() != right_var->get_name()
7370
        || !(left_var->get_type() == right_var->get_type())
7371
        || left_var->is_readonly() != right_var->is_readonly()
7372
        || left_var->is_not_null() != right_var->is_not_null()
7373
        || left_var->is_default_construct() != right_var->is_default_construct()
7374
        || left_var->is_formal_param() != right_var->is_formal_param()) {
7375
      legal = false;
7376
    }
7377
    if (OB_SUCC(ret) && legal && left_default_expr != right_default_expr) {
7378
      if (OB_ISNULL(left_default_expr) || OB_ISNULL(right_default_expr)) {
7379
        legal = false;
7380
      } else if (!left_default_expr->same_as(*right_default_expr)) {
7381
        legal = false;
7382
      }
7383
    }
7384
  }
7385
  return ret;
7386
}
7387

7388
int ObPLResolver::replace_cursor_formal_params(const ObIArray<int64_t> &src_formal_exprs,
7389
                                               const ObIArray<int64_t> &dst_formal_exprs,
7390
                                               uint64_t src_package_id,
7391
                                               uint64_t dst_package_id,
7392
                                               ObIArray<ObRawExpr *> &sql_params)
7393
{
7394
  int ret = OB_SUCCESS;
7395
  if (src_package_id != dst_package_id) {
7396
    for (int64_t i = 0; OB_SUCC(ret) && i < sql_params.count(); ++i) {
7397
      ObRawExpr* raw_expr = sql_params.at(i);
7398
      CK (OB_NOT_NULL(raw_expr));
7399
      OZ (replace_cursor_formal_params(
7400
        src_formal_exprs, dst_formal_exprs, src_package_id, dst_package_id, *raw_expr));
7401
    }
7402
  }
7403
  return ret;
7404
}
7405

7406
int ObPLResolver::replace_cursor_formal_params(const ObIArray<int64_t> &src_formal_exprs,
7407
                                               const ObIArray<int64_t> &dst_formal_exprs,
7408
                                               uint64_t src_package_id,
7409
                                               uint64_t dst_package_id,
7410
                                               ObRawExpr &expr)
7411
{
7412
  int ret = OB_SUCCESS;
7413
  if (expr.get_expr_type() == T_OP_GET_PACKAGE_VAR) {
7414
    ObSysFunRawExpr &f_expr = static_cast<ObSysFunRawExpr &>(expr);
7415
    uint64_t package_id = OB_INVALID_ID;
7416
    int64_t var_idx = OB_INVALID_ID;
7417
    CK (f_expr.get_param_count() >= 2);
7418
    OZ (ObRawExprUtils::get_package_var_ids(&f_expr, package_id, var_idx));
7419
    if (OB_SUCC(ret) && package_id == src_package_id) {
7420
      for (int64_t i = 0; OB_SUCC(ret) && i < src_formal_exprs.count(); ++i) {
7421
        if (var_idx == src_formal_exprs.at(i)) {
7422
          OZ (ObRawExprUtils::set_package_var_ids(
7423
            &f_expr, dst_package_id, dst_formal_exprs.at(i)));
7424
          break;
7425
        }
7426
      }
7427
    }
7428
  } else {
7429
    for (int64_t i = 0; OB_SUCC(ret) && i < expr.get_param_count(); ++i) {
7430
      ObRawExpr *param = expr.get_param_expr(i);
7431
      CK (OB_NOT_NULL(param));
7432
      OZ (replace_cursor_formal_params(
7433
        src_formal_exprs, dst_formal_exprs, src_package_id, dst_package_id, *param));
7434
    }
7435
  }
7436
  return ret;
7437
}
7438

7439
int ObPLResolver::resolve_cursor_def(const ObString &cursor_name,
7440
                                      const ObStmtNodeTree *sql_node,
7441
                                      ObPLBlockNS &sql_ns,
7442
                                      ObPLDataType &cursor_type,
7443
                                      const ObIArray<int64_t> &formal_params,
7444
                                      ObPLCompileUnitAST &func,
7445
                                      int64_t &cursor_index) // CURSOR 在符号表中的下标
7446
{
7447
  int ret = OB_SUCCESS;
7448
  ObRecordType *record_type = NULL;
7449
  ObArray<int64_t> expr_idxs;
7450
  int64_t index = common::OB_INVALID_INDEX;
7451
  sql::ObSPIService::ObSPIPrepareResult prepare_result;
7452
  CK (OB_NOT_NULL(sql_node));
7453
  if (OB_SUCC(ret)) {
7454
    if (OB_ISNULL(record_type = static_cast<ObRecordType*>(resolve_ctx_.allocator_.alloc(sizeof(ObRecordType))))) {
7455
      ret = OB_ALLOCATE_MEMORY_FAILED;
7456
      LOG_WARN("failed to alloc memory", K(ret));
7457
    } else {
7458
      int64_t current_time = ObTimeUtility::current_time();
7459
      ObSqlString record_name;
7460
      char* name_buf = NULL;
7461
      if (OB_FAIL(record_name.append_fmt("__for_loop_cursor_record_name_%ld", current_time))) {
7462
        LOG_WARN("failed to generate cursor record name", K(ret));
7463
      } else if (OB_ISNULL(name_buf = static_cast<char*>(resolve_ctx_.allocator_.alloc(record_name.length() + 1)))) {
7464
        ret = OB_ALLOCATE_MEMORY_FAILED;
7465
        LOG_WARN("failed to allocate record name", K(ret));
7466
      } else {
7467
        record_name.to_string(name_buf, record_name.length() + 1);
7468
        record_type = new(record_type)ObRecordType();
7469
        record_type->set_name(ObString(record_name.length(), name_buf));
7470
        record_type->set_type_from(PL_TYPE_ATTR_ROWTYPE);
7471
        prepare_result.record_type_ = record_type;
7472
        prepare_result.tg_timing_event_ =
7473
                                static_cast<TgTimingEvent>(resolve_ctx_.params_.tg_timing_event_);
7474
      }
7475
    }
7476
  }
7477
  if (OB_SUCC(ret)) {
7478
    if (OB_FAIL(ObSPIService::spi_prepare(resolve_ctx_.allocator_,
7479
                                          resolve_ctx_.session_info_,
7480
                                          resolve_ctx_.sql_proxy_,
7481
                                          resolve_ctx_.schema_guard_,
7482
                                          expr_factory_,
7483
                                          sql_node->str_value_,
7484
                                          true, /*is_cursor*/
7485
                                          &sql_ns,
7486
                                          prepare_result))) {
7487
      LOG_WARN("failed to prepare stmt", K(ret));
7488
    } else if (!prepare_result.into_exprs_.empty()
7489
               && lib::is_mysql_mode()) { // oracle不报错,会忽略掉INTO
7490
      ret = OB_ER_SP_BAD_CURSOR_SELECT;
7491
      LOG_USER_ERROR(OB_ER_SP_BAD_CURSOR_SELECT);
7492
      LOG_WARN("Sql with into clause should not in Declare cursor", K(prepare_result.route_sql_), K(ret));
7493
    } else if (OB_FAIL(func.add_sql_exprs(prepare_result.exec_params_))) {
7494
      LOG_WARN("failed to set precalc exprs", K(prepare_result.exec_params_), K(ret));
7495
    }
7496
    if (OB_SUCC(ret)) {
7497
      if (prepare_result.for_update_) {
7498
        func.set_modifies_sql_data();
7499
      } else if (!func.is_modifies_sql_data()) {
7500
        func.set_reads_sql_data();
7501
      }
7502
    }
7503
    if (OB_SUCC(ret)) {
7504
      if (OB_FAIL(func.add_dependency_objects(prepare_result.ref_objects_))) {
7505
        LOG_WARN("failed to set ref object", K(prepare_result.ref_objects_), K(ret));
7506
      } else {
7507
        // sql contain package var or package udf
7508
        for (int64_t i = 0; OB_SUCC(ret) && i < prepare_result.ref_objects_.count(); ++i) {
7509
          if (DEPENDENCY_PACKAGE == prepare_result.ref_objects_.at(i).object_type_ ||
7510
              DEPENDENCY_PACKAGE_BODY == prepare_result.ref_objects_.at(i).object_type_ ||
7511
              DEPENDENCY_FUNCTION == prepare_result.ref_objects_.at(i).object_type_) {
7512
            func.set_external_state();
7513
          }
7514
        }
7515
      }
7516
    }
7517
  }
7518
  if (OB_SUCC(ret)) {
7519
    for (int64_t i = func.get_expr_count() - prepare_result.exec_params_.count();
7520
      OB_SUCC(ret) && i < func.get_expr_count();
7521
      ++i) {
7522
      if (OB_FAIL(expr_idxs.push_back(i))) {
7523
        LOG_WARN("push_back error", K(i), K(ret));
7524
      }
7525
    }
7526
  }
7527
  if (OB_SUCC(ret) && OB_NOT_NULL(record_type)) {
7528
    OZ (current_block_->get_namespace().add_type(record_type));
7529
    if (OB_FAIL(ret)) {
7530
    } else if (!cursor_type.is_valid_type()) {
7531
      cursor_type.set_user_type_id(record_type->get_type(), record_type->get_user_type_id());
7532
      cursor_type.set_type_from(record_type->get_type_from());
7533
    } else {
7534
      ObArenaAllocator allocator;
7535
      const ObUserDefinedType *cursor_user_type = NULL;
7536
      if (OB_FAIL(current_block_->get_namespace().get_user_type(cursor_type.get_user_type_id(),
7537
                                                                cursor_user_type, &allocator))) {
7538
        LOG_WARN("failed to get user type", K(cursor_type), K(ret));
7539
      } else if (OB_ISNULL(cursor_user_type)) {
7540
        ret = OB_ERR_UNEXPECTED;
7541
        LOG_WARN("failed to get cursor type", K(cursor_type), K(ret));
7542
      } else if (!cursor_user_type->is_record_type()) {
7543
        ret = OB_ERR_UNEXPECTED;
7544
        LOG_WARN("cursor must return record type", K(*cursor_user_type), K(ret));
7545
      } else {
7546
        bool is_compatible = false;
7547
        const ObRecordType *return_type = static_cast<const ObRecordType*>(cursor_user_type);
7548
        if (OB_FAIL(record_type->is_compatble(*return_type, is_compatible))) {
7549
          LOG_WARN("failed to check compatible", K(*record_type), K(*return_type), K(ret));
7550
        } else if (!is_compatible) {
7551
          ret = OB_OBJ_TYPE_ERROR;
7552
          LOG_WARN("type not compatible", K(*record_type), K(*return_type), K(ret));
7553
        } else { /*do nothing*/ }
7554
      }
7555
    }
7556
  }
7557
  if (OB_SUCC(ret)) {
7558
    if (OB_INVALID_ID ==  cursor_index) {
7559
      ObPLDataType type(PL_CURSOR_TYPE);
7560
      type.set_user_type_id(PL_CURSOR_TYPE, record_type->get_user_type_id());
7561
      if (OB_FAIL(current_block_->get_namespace().add_cursor(cursor_name,
7562
                                                             type,
7563
                                                             prepare_result.route_sql_,
7564
                                                             expr_idxs,
7565
                                                             prepare_result.ps_sql_,
7566
                                                             prepare_result.type_,
7567
                                                             prepare_result.for_update_,
7568
                                                             prepare_result.has_hidden_rowid_,
7569
                                                             prepare_result.rowid_table_id_,
7570
                                                             prepare_result.ref_objects_,
7571
                                                             record_type,
7572
                                                             cursor_type,
7573
                                                             formal_params,
7574
                                                             ObPLCursor::DEFINED,
7575
                                                             prepare_result.has_dup_column_name_,
7576
                                                             index,
7577
                                                             prepare_result.is_skip_locked_))) {
7578
        LOG_WARN("failed to add cursor to symbol table",
7579
                 K(cursor_name),
7580
                 K(sql_node->str_value_),
7581
                 K(prepare_result.exec_params_),
7582
                 K(prepare_result.ps_sql_),
7583
                 K(prepare_result.type_),
7584
                 K(prepare_result.for_update_),
7585
                 K(ret));
7586
      } else {
7587
        cursor_index = index;
7588
      }
7589
    } else {
7590
      ObPLCursor *cursor = current_block_->get_cursor(cursor_index);
7591
      if (OB_ISNULL(cursor)) {
7592
        ret = OB_ERR_UNEXPECTED;
7593
        LOG_WARN("cursor NULL", K(cursor_index), K(cursor_name), K(ret));
7594
      } else {
7595
        const ObPLVar *var = nullptr;
7596
        OZ (current_block_->get_namespace().get_cursor_var(
7597
        cursor->get_package_id(), cursor->get_routine_id(), cursor->get_index(), var));
7598
        CK (OB_NOT_NULL(var));
7599
        if (OB_SUCC(ret)) {
7600
          ObPLDataType type(PL_CURSOR_TYPE);
7601
          type.set_user_type_id(PL_CURSOR_TYPE, record_type->get_user_type_id());
7602
          const_cast<ObPLVar *>(var)->set_type(type);
7603
        }
7604
        /*
7605
         * 检查Oracle模式游标是否有重定义：
7606
         * Oracle在游标重定义方面的表现很奇怪，如果同一个游标名被先声明后定义的原型不同（参数或者返回值类型不同），
7607
         * 甚至同一个游标名被定义了两次，只要这个游标没有被访问过，就不会报错。
7608
         * 所以如果我们在定义的时候找到以前declare或define过，那么要先检查是否是合法的define。
7609
         * 对于重复定义，或者声明和定义不一致，我们不能在这里报错，而必须在访问游标时才报错，所以在这里只设置游标状态，
7610
         * 而等待在resolve_cursor的时候检查出来在报错。
7611
         * */
7612
        bool same_cursor_declare = false;
7613
        if (ObPLCursor::DECLARED == cursor->get_state()
7614
            && cursor_type == cursor->get_cursor_type()) {
7615
          OZ (check_cursor_formal_params(formal_params, *cursor, same_cursor_declare));
7616
        }
7617
        if (OB_FAIL(ret)) {
7618
        } else if (same_cursor_declare) {
7619
          // 声明在包头，定义在包体，sql中引用的cursor参数符号在包体中，此时需要替换成包头中的符号
7620
          OZ (replace_cursor_formal_params(formal_params,
7621
                                           cursor->get_formal_params(),
7622
                                           current_block_->get_namespace().get_package_id(),
7623
                                           cursor->get_package_id(),
7624
                                           prepare_result.exec_params_));
7625
          //仅当原型和声明完全一致时，才是合法
7626
          OZ (cursor->set(prepare_result.route_sql_,
7627
                          expr_idxs,
7628
                          prepare_result.ps_sql_,
7629
                          prepare_result.type_,
7630
                          prepare_result.for_update_,
7631
                          record_type,
7632
                          cursor_type,
7633
                          ObPLCursor::DEFINED,
7634
                          prepare_result.ref_objects_,
7635
                          cursor->get_formal_params(),
7636
                          prepare_result.has_dup_column_name_));
7637
          if (OB_SUCC(ret)
7638
          && (cursor->get_package_id() != current_block_->get_namespace().get_package_id()
7639
              || cursor->get_routine_id() != current_block_->get_namespace().get_routine_id())) {
7640
            const ObPLCursor *external_cursor = NULL;
7641
            ObPLBlockNS *external_ns = NULL;
7642
            CK (OB_NOT_NULL(current_block_->get_namespace().get_external_ns()));
7643
            CK (OB_NOT_NULL(external_ns = const_cast<ObPLBlockNS *>(current_block_->get_namespace().get_external_ns()->get_parent_ns())));
7644
            OZ (current_block_->get_namespace().get_external_ns()->get_parent_ns()->get_cursor(
7645
                cursor->get_package_id(),
7646
                cursor->get_routine_id(),
7647
                cursor->get_index(),
7648
                external_cursor));
7649
            if (OB_SUCC(ret)) {
7650
              if (OB_ISNULL(external_cursor)) {
7651
                ret = OB_ERR_UNEXPECTED;
7652
                LOG_WARN("cursor NULL", K(cursor_index), K(cursor_name), K(ret));
7653
              } else {
7654
                ObSEArray<int64_t, 16> external_expr_idxs;
7655
                ObIArray<ObRawExpr *> *external_exprs = const_cast<ObIArray<ObRawExpr*>*>(external_ns->get_exprs());
7656
                CK (OB_NOT_NULL(external_exprs));
7657
                for (int64_t i = 0; OB_SUCC(ret) && i < expr_idxs.count(); ++i) {
7658
                  OZ (external_expr_idxs.push_back(external_exprs->count()));
7659
                  OZ (external_exprs->push_back(func.get_exprs().at(expr_idxs.at(i))));
7660
                }
7661
                OZ (const_cast<ObPLCursor*>(external_cursor)->set(prepare_result.route_sql_,
7662
                                          external_expr_idxs,
7663
                                          prepare_result.ps_sql_,
7664
                                          prepare_result.type_,
7665
                                          prepare_result.for_update_,
7666
                                          record_type,
7667
                                          cursor_type,
7668
                                          ObPLCursor::DEFINED,
7669
                                          prepare_result.ref_objects_,
7670
                                          external_cursor->get_formal_params(),
7671
                                          prepare_result.has_dup_column_name_),
7672
                                          K(formal_params),
7673
                                          K(external_cursor->get_formal_params()));
7674
              }
7675
            }
7676
          }
7677
        } else if (ObPLCursor::DEFINED == cursor->get_state()) {
7678
          // already defined, do not defined it agine.
7679
          ret = OB_ERR_ATTR_FUNC_CONFLICT;
7680
          LOG_USER_ERROR(OB_ERR_ATTR_FUNC_CONFLICT, cursor_name.length(), cursor_name.ptr());
7681
        } else { //不合法的定义不用去做define，直接设置cursor状态
7682
          cursor->set_state(ObPLCursor::DUP_DECL);
7683
        }
7684
      }
7685
    }
7686
  }
7687
  return ret;
7688
}
7689

7690
int ObPLResolver::resolve_declare_cursor(const ObStmtNodeTree *parse_tree, ObPLPackageAST &func)
7691
{
7692
  int ret = OB_SUCCESS;
7693
  OZ (resolve_declare_cursor(parse_tree, NULL, func));
7694
  return ret;
7695
}
7696

7697
int ObPLResolver::resolve_declare_cursor(
7698
  const ObStmtNodeTree *parse_tree, ObPLDeclareCursorStmt *stmt, ObPLCompileUnitAST &func)
7699
{
7700
  int ret = OB_SUCCESS;
7701
  if (OB_ISNULL(parse_tree) || OB_ISNULL(current_block_)) {
7702
    ret = OB_INVALID_ARGUMENT;
7703
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(current_block_), K(ret));
7704
  } else {
7705
    //解析name
7706
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
7707
    const ObStmtNodeTree *param_node = parse_tree->children_[1];
7708
    const ObStmtNodeTree *type_node = parse_tree->children_[2];
7709
    const ObStmtNodeTree *sql_node = parse_tree->children_[3];
7710
    if (OB_ISNULL(name_node)) {
7711
      ret = OB_ERR_UNEXPECTED;
7712
      LOG_WARN("parse_tree is NULL", K(name_node), K(ret));
7713
    } else if (lib::is_mysql_mode() && (NULL != type_node || NULL == sql_node)) {
7714
      ret = OB_INVALID_ARGUMENT;
7715
      LOG_WARN("cursor in mysql mode must has no type node and has a valid sql node", K(type_node), K(sql_node), K(ret));
7716
    } else if (lib::is_oracle_mode() && NULL ==type_node && NULL == sql_node) {
7717
      ret = OB_ERR_CURSOR_NO_RETURN_TYPE;
7718
      LOG_WARN("cursor declare must has retrun type", K(type_node), K(sql_node), K(ret));
7719
    } else {
7720
      ObString name;
7721
      ObPLDataType return_type;
7722
      ObArray<int64_t> formal_params;
7723
      int64_t cursor_index = common::OB_INVALID_INDEX;
7724
      ObPLStmtBlock *current_block = current_block_;
7725
      ObPLStmtBlock *cursor_block = current_block_;
7726
      question_mark_cnt_ = parse_tree->value_;
7727

7728
      OZ (resolve_cursor_common(name_node, type_node, func, name, return_type));
7729

7730
      if (OB_SUCC(ret) && NULL != param_node) {
7731
        if (func.is_routine()) {
7732
          OZ (make_block(
7733
            static_cast<ObPLFunctionAST&>(func), current_block, cursor_block));
7734
          OX (set_current(*cursor_block));
7735
        } else {
7736
          OZ (make_block(static_cast<ObPLPackageAST&>(func), cursor_block));
7737
          OX (cursor_block->get_namespace().set_pre_ns(
7738
            NULL == current_block ? NULL : &current_block->get_namespace()));
7739
          OX (set_current(*cursor_block));
7740
        }
7741
        OZ (resolve_cursor_formal_param(param_node, func, formal_params));
7742
        OX (set_current(*current_block));
7743
      }
7744

7745
      if (OB_SUCC(ret)) {
7746
        if (OB_FAIL(resolve_cursor(name,
7747
                                   current_block_->get_namespace(),
7748
                                   cursor_index,
7749
                                   func,
7750
                                   true/*check mode*/))) {
7751
          LOG_WARN("failed to resolve cursor", K(ret), K(name));
7752
        } else if (lib::is_mysql_mode() && OB_INVALID_INDEX != cursor_index) {
7753
          ret = OB_ERR_SP_DUP_CURSOR;
7754
          LOG_WARN("Duplicate cursor", K(name),K(ret));
7755
          LOG_USER_ERROR(OB_ERR_SP_DUP_CURSOR, name.length(), name.ptr());
7756
        } else if (NULL == sql_node) { //only declare
7757
          if (OB_INVALID_INDEX == cursor_index) { //没有declare过，添加进符号表
7758
            if (OB_FAIL(current_block_->get_namespace().add_cursor(name,
7759
                                                                   ObPLDataType(PL_CURSOR_TYPE),
7760
                                                                   ObString(),
7761
                                                                   ObArray<int64_t>(),
7762
                                                                   ObString(),
7763
                                                                   stmt::T_NONE,
7764
                                                                   false, //for update
7765
                                                                   false, //hidden rowid
7766
                                                                   OB_INVALID_ID,
7767
                                                                   ObArray<ObSchemaObjVersion>(),
7768
                                                                   NULL,
7769
                                                                   return_type,
7770
                                                                   formal_params,
7771
                                                                   ObPLCursor::DECLARED,
7772
                                                                   false,
7773
                                                                   cursor_index))) {
7774
              LOG_WARN("failed to add cursor to symbol table", K(name), K(ret));
7775
            } else if (OB_NOT_NULL(stmt)) {
7776
              stmt->set_cursor_index(cursor_index);
7777
            } else { /*do nothing*/ }
7778
          } else {
7779
            ret = OB_ERR_SP_DUP_CURSOR;
7780
            LOG_WARN("PLS-00305: previous use of cursor conflicts with this use", K(name),K(ret));
7781
          }
7782
        } else { //declare and define
7783
          if (OB_FAIL(resolve_cursor_def(name, sql_node, cursor_block->get_namespace(),
7784
                                         return_type, formal_params, func, cursor_index))) {
7785
            LOG_WARN("failed to resolve cursor comm", K(ret), K(name));
7786
          } else if (OB_NOT_NULL(stmt)) {
7787
            stmt->set_cursor_index(cursor_index);
7788
          } else { /*do nothing*/ }
7789
        }
7790
      }
7791
    }
7792
  }
7793
  return ret;
7794
}
7795

7796
int ObPLResolver::resolve_cursor_common(const ObStmtNodeTree *name_node,
7797
                                        const ObStmtNodeTree *type_node,
7798
                                        ObPLCompileUnitAST &func,
7799
                                        ObString &name,
7800
                                        ObPLDataType &return_type)
7801
{
7802
  int ret = OB_SUCCESS;
7803
  if (OB_FAIL(resolve_ident(name_node, name))) {
7804
    LOG_WARN("failed to resolve ident", K(name_node), K(ret));
7805
  } else if (NULL != type_node) {
7806
    if (OB_FAIL(resolve_sp_data_type(type_node, name, func, return_type))) {
7807
      LOG_WARN("failed to resolve return type", K(type_node), K(name), K(ret));
7808
    } else if (!return_type.is_record_type()) {
7809
      ret = OB_ERR_TYPE_DECL_MALFORMED;
7810
      LOG_WARN("PLS-00320: the declaration of the type of this expression is incomplete or malformed",
7811
               K(ret), K(return_type));
7812
    }
7813
  } else { /*do nothing*/ }
7814
  return ret;
7815
}
7816

7817
int ObPLResolver::resolve_cursor_formal_param(
7818
  const ObStmtNodeTree *param_list, ObPLCompileUnitAST &func, ObIArray<int64_t> &params)
7819
{
7820
  int ret = OB_SUCCESS;
7821
  if (OB_ISNULL(current_block_) || OB_ISNULL(param_list)) {
7822
    ret = OB_ERR_UNEXPECTED;
7823
    LOG_WARN("argument invalid", K(current_block_), K(param_list), K(ret));
7824
  } else if (param_list->type_ != T_SP_PARAM_LIST || OB_ISNULL(param_list->children_)) {
7825
    ret = OB_ERR_UNEXPECTED;
7826
    LOG_WARN("param list type is invalid", K(param_list->type_), K(param_list->children_), K(ret));
7827
  } else {
7828
    ObString param_name;
7829
    ObPLDataType param_type;
7830
    for (int64_t i = 0; OB_SUCC(ret) && i < param_list->num_child_; ++i) {
7831
      const ParseNode *param_node = param_list->children_[i];
7832
      const ParseNode *name_node = NULL;
7833
      const ParseNode *type_node = NULL;
7834
      param_name.reset();
7835
      param_type.reset();
7836
      if (OB_ISNULL(param_node)
7837
          || OB_UNLIKELY(param_node->type_ != T_SP_PARAM)
7838
          || OB_ISNULL(param_node->children_)) {
7839
        ret = OB_ERR_UNEXPECTED;
7840
        LOG_WARN("param node is invalide", K(param_node), K_(param_node->children));
7841
      } else if (OB_ISNULL(name_node = param_node->children_[0])
7842
          || OB_ISNULL(type_node = param_node->children_[1])) {
7843
        ret = OB_ERR_UNEXPECTED;
7844
        LOG_WARN("name node or type node is null", K(name_node), K(type_node));
7845
      } else {
7846
        ObRawExpr *default_expr = NULL;
7847
        param_name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));
7848
        if (OB_FAIL(resolve_sp_data_type(type_node, param_name, func, param_type))) {
7849
          LOG_WARN("resolve data type failed", K(ret), K(param_name));
7850
        } else if (MODE_IN != param_node->value_) {
7851
          ret = OB_INVALID_ARGUMENT;
7852
          LOG_WARN("param inout flag is invalid", K(param_node->value_), K(ret));
7853
        } else if (OB_NOT_NULL(param_node->children_[2])) {
7854
          ParseNode* default_node = param_node->children_[2];
7855
          if (default_node->type_ != T_SP_DECL_DEFAULT) {
7856
            ret = OB_ERR_UNEXPECTED;
7857
            LOG_WARN("default node type is unexpected", K(ret));
7858
          } else if (OB_FAIL(resolve_expr(default_node->children_[0],
7859
                                          func, default_expr,
7860
                                          combine_line_and_col(default_node->stmt_loc_),
7861
                                          true /*need_add*/,
7862
                                          &param_type))) {
7863
            LOG_WARN("failed to resolve default expr", K(ret));
7864
          } else if (OB_ISNULL(default_expr)) {
7865
            ret = OB_ERR_UNEXPECTED;
7866
            LOG_WARN("failed to resolve default expr", K(ret), K(default_expr));
7867
          } else { /*do nothing*/ }
7868
        }
7869

7870
        if (OB_SUCC(ret)) {
7871
          if (OB_FAIL(current_block_->get_namespace().add_symbol(param_name, param_type, default_expr,
7872
                                                                 false, false, false, true))) {
7873
            LOG_WARN("failed to add symbol", K(param_name), K(param_type), K(default_expr), K(ret));
7874
          } else if (OB_FAIL(params.push_back(current_block_->get_namespace().get_symbol_table()->get_count() - 1))) {
7875
            LOG_WARN("push back error", K(params), K(param_type), K(default_expr), K(ret));
7876
          } else { /*do nothing*/ }
7877
        }
7878
      }
7879
    }
7880
  }
7881
  return ret;
7882
}
7883

7884
#ifdef OB_BUILD_ORACLE_PL
7885
int ObPLResolver::resolve_declare_ref_cursor(
7886
  const ObStmtNodeTree *parse_tree, ObPLDeclareCursorStmt *stmt, ObPLFunctionAST &func)
7887
{
7888
  int ret = OB_SUCCESS;
7889
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
7890
    ret = OB_INVALID_ARGUMENT;
7891
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
7892
  } else {
7893
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
7894
    const ObStmtNodeTree *type_node = parse_tree->children_[1];
7895
    ObPLDataType data_type;
7896
    ObString ident_name;
7897
    CK (OB_NOT_NULL(type_node));
7898
    OZ (resolve_sp_data_type(type_node, ident_name, func, data_type));
7899
    CK (data_type.is_cursor_type());
7900
    CK (OB_NOT_NULL(name_node));
7901
    if (OB_SUCC(ret)) {
7902
      if (1 != name_node->num_child_) {
7903
        ret = OB_NOT_SUPPORTED;
7904
        LOG_WARN("name list for ref cursor is not supported yet", K(name_node->num_child_), K(ret));
7905
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "name list for ref cursor");
7906
      } else {
7907
        OZ (resolve_ident(name_node->children_[0], ident_name));
7908
      }
7909
    }
7910

7911
    if (OB_SUCC(ret)) {
7912
      ObArenaAllocator allocator;
7913
      const ObUserDefinedType *cursor_type = NULL;
7914
      const ObUserDefinedType *return_type = NULL;
7915
      int64_t index = OB_INVALID_INDEX;
7916
      if (OB_FAIL(current_block_->get_namespace().get_user_type(data_type.get_user_type_id(),
7917
          cursor_type, &allocator))) {
7918
        LOG_WARN("failed to get user type", K(data_type), K(ret));
7919
      } else if (OB_ISNULL(cursor_type)) {
7920
        ret = OB_ERR_UNEXPECTED;
7921
        LOG_WARN("failed to get cursor type", K(data_type), K(ret));
7922
      } else {
7923
        uint64_t return_type_id = static_cast<const ObRefCursorType*>(cursor_type)->get_return_type_id();
7924
        if (OB_INVALID_ID != return_type_id) {
7925
          if (OB_FAIL(current_block_->get_namespace().get_user_type(return_type_id, return_type))) {
7926
            LOG_WARN("failed to get user type", K(*cursor_type), K(ret));
7927
          } else if (OB_ISNULL(return_type)) {
7928
            ret = OB_ERR_UNEXPECTED;
7929
            LOG_WARN("failed to get cursor type", K(*cursor_type), K(ret));
7930
          } else { /*do nothing*/ }
7931
        }
7932
      }
7933

7934
      if (OB_SUCC(ret)) {
7935
        ObString dummy_sql;
7936
        ObArray<int64_t> dummy_params;
7937
        sql::stmt::StmtType dummy_stmt_type = sql::stmt::T_NONE;
7938
        bool dummy_for_update = false;
7939
        bool dummy_hidden_rowid = false;
7940
        common::ObArray<ObSchemaObjVersion> dummy_ref_objects;
7941
        const ObPLDataType dummy_return_type;
7942
        const ObArray<int64_t> dummy_formal_params;
7943
        if (OB_FAIL(current_block_->get_namespace().add_cursor(ident_name,
7944
                                                               data_type,
7945
                                                               dummy_sql,
7946
                                                               dummy_params,
7947
                                                               dummy_sql,
7948
                                                               dummy_stmt_type,
7949
                                                               dummy_for_update,
7950
                                                               dummy_hidden_rowid,
7951
                                                               OB_INVALID_ID,
7952
                                                               dummy_ref_objects,
7953
                                                               NULL, /*ref cursor的row desc不确定*/
7954
                                                               NULL == return_type ? dummy_return_type : *return_type,
7955
                                                               dummy_formal_params,
7956
                                                               ObPLCursor::DECLARED,
7957
                                                               false,
7958
                                                               index))) {
7959
           LOG_WARN("failed to add cursor to symbol table", K(ident_name), K(return_type), K(index), K(ret));
7960
        } else {
7961
          stmt->set_cursor_index(index);
7962
        }
7963
      }
7964
    }
7965
  }
7966
  return ret;
7967
}
7968
#endif
7969

7970
int ObPLResolver::resolve_open(
7971
  const ObStmtNodeTree *parse_tree, ObPLOpenStmt *stmt, ObPLFunctionAST &func)
7972
{
7973
  int ret = OB_SUCCESS;
7974
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
7975
    ret = OB_INVALID_ARGUMENT;
7976
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
7977
  } else {
7978
    // 解析Cursor
7979
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
7980
    int64_t index = OB_INVALID_INDEX;
7981
    OZ (resolve_cursor(name_node, current_block_->get_namespace(), index, func));
7982
    OX (stmt->set_cursor_index(index));
7983
    if (OB_SUCC(ret)) {
7984
      const ObPLVar *var = NULL;
7985
      if (OB_FAIL(stmt->get_var(var))) {
7986
        LOG_WARN("failed to get var", K(ret));
7987
      } else if (NULL == var) {
7988
        //非local cursor，一定不是只读的
7989
      } else if (var->get_type().is_ref_cursor_type() && stmt->get_type() != PL_OPEN_FOR) {
7990
        ret = OB_ERR_EXPRESSION_WRONG_TYPE;
7991
        LOG_WARN("use open stmt with a ref cursor is not property.", K(ret), K(index));
7992
      } else if (var->is_readonly()) {
7993
        /* 也有可能是子过程的parent cursor，不应是in的cursor
7994
         *create or replace procedure subproc is
7995
          cur sys_refcursor;
7996
          procedure subproc1 is
7997
          begin
7998
          open cur for select * from tbl_xxx;
7999
          end;
8000
          begin
8001
          subproc1;
8002
          close cur;
8003
          end;
8004
         */
8005
        ret = OB_ERR_IN_CURSOR_OPEND;
8006
        LOG_WARN("PLS-00361: IN cursor cannot be OPEN'ed", K(ret), KPC(var));
8007
      } else {
8008
        // 判断是否对外部cursor进行open，这儿会决定这个cursor的内存是否在session内存上
8009
        ObPLCursor *cursor = NULL;
8010
        cursor = current_block_->get_namespace().get_cursor_table()->get_cursor(index);
8011
        if (OB_SUCC(ret) && OB_NOT_NULL(cursor)) {
8012
          if (cursor->is_for_update()) {
8013
            func.set_modifies_sql_data();
8014
          }
8015
          if (PL_REF_CURSOR_TYPE == cursor->get_cursor_type().get_type()) {
8016
            if (cursor->get_package_id() != current_block_->get_namespace().get_package_id()
8017
                || cursor->get_routine_id() != current_block_->get_namespace().get_routine_id()) {
8018
              func.set_open_external_ref_cursor();
8019
              func.set_external_state();
8020
            }
8021
          } else {
8022
            if (!var->get_pl_data_type().is_ref_cursor_type()
8023
                && ObPLCursor::DEFINED != cursor->get_state()) {
8024
              ret = OB_ERR_TYPE_DECL_MALFORMED;
8025
              LOG_WARN("cursor not defined", KPC(var), KPC(cursor), K(ret));
8026
            }
8027
          }
8028
        }
8029
      }
8030
    }
8031
  }
8032

8033
  //解析实参
8034
  if (OB_SUCC(ret)) {
8035
    const ObStmtNodeTree *param_node = parse_tree->children_[1];
8036
    if (OB_FAIL(resolve_cursor_actual_params(param_node, stmt, func))) {
8037
      LOG_WARN("failed to resolve cursor actual params", K(ret));
8038
    }
8039
  }
8040
  return ret;
8041
}
8042

8043
int ObPLResolver::convert_cursor_actual_params(
8044
  ObRawExpr *expr, ObPLDataType pl_data_type, ObPLFunctionAST &func, int64_t &idx)
8045
{
8046
  int ret = OB_SUCCESS;
8047
  ObDataType *data_type = pl_data_type.get_data_type();
8048
  ObRawExpr *convert_expr = expr;
8049
  if (T_SP_CPARAM == expr->get_expr_type()) {
8050
    ObCallParamRawExpr *call_expr = static_cast<ObCallParamRawExpr *>(expr);
8051
    CK (OB_NOT_NULL(call_expr));
8052
    CK (OB_NOT_NULL(call_expr->get_expr()));
8053
    OX (convert_expr = call_expr->get_expr());
8054
  }
8055
  CK (OB_NOT_NULL(convert_expr));
8056
  if (OB_FAIL(ret)) {
8057
  } else if (OB_NOT_NULL(data_type)) {
8058
    OZ (ObRawExprUtils::build_column_conv_expr(&resolve_ctx_.session_info_,
8059
                                               expr_factory_,
8060
                                               data_type->get_obj_type(),
8061
                                               data_type->get_collation_type(),
8062
                                               data_type->get_accuracy_value(),
8063
                                               true,
8064
                                               NULL,
8065
                                               NULL,
8066
                                               convert_expr));
8067
    OZ (func.add_expr(convert_expr));
8068
    OX (idx = func.get_exprs().count() - 1);
8069
  } else if (pl_data_type.is_cursor_type()) {
8070
    if (convert_expr->get_result_type().get_extend_type() != PL_CURSOR_TYPE
8071
        && convert_expr->get_result_type().get_extend_type() != PL_REF_CURSOR_TYPE) {
8072
      ret = OB_ERR_INVALID_TYPE_FOR_OP;
8073
      LOG_WARN("PLS-00382: expression is of wrong type",
8074
                  K(ret), K(pl_data_type.is_obj_type()), KPC(convert_expr),
8075
                  K(convert_expr->get_result_type().get_obj_meta().get_type()),
8076
                  K(pl_data_type.get_user_type_id()),
8077
                  K(convert_expr->get_result_type().get_udt_id()));
8078
    }
8079
  } else if (pl_data_type.get_user_type_id() != convert_expr->get_result_type().get_udt_id()) {
8080
    bool is_compatible = false;
8081
    if (convert_expr->get_result_type().is_null()) {
8082
      is_compatible = true;
8083
    } else if (convert_expr->get_result_type().is_ext()) {
8084
      CK (OB_NOT_NULL(current_block_));
8085
      OZ (check_composite_compatible(current_block_->get_namespace(),
8086
                                     pl_data_type.get_user_type_id(),
8087
                                     convert_expr->get_result_type().get_udt_id(),
8088
                                     is_compatible));
8089
    }
8090
    if (OB_SUCC(ret) && !is_compatible) {
8091
      ret = OB_ERR_INVALID_TYPE_FOR_OP;
8092
      LOG_WARN("PLS-00382: expression is of wrong type",
8093
                  K(ret), K(pl_data_type.is_obj_type()), KPC(convert_expr),
8094
                  K(convert_expr->get_result_type().get_obj_meta().get_type()),
8095
                  K(pl_data_type.get_user_type_id()),
8096
                  K(convert_expr->get_result_type().get_udt_id()));
8097
    }
8098
  }
8099
  return ret;
8100
}
8101

8102
int ObPLResolver::resolve_cursor_actual_params(
8103
  const ObStmtNodeTree *parse_tree, ObPLStmt *stmt, ObPLFunctionAST &func)
8104
{
8105
  int ret = OB_SUCCESS;
8106
  ObSEArray<ObRawExpr*, 32> exprs;
8107
  ObSEArray<ObIRoutineParam*, 16> iparams;
8108
  const ObPLCursor *cursor =
8109
    (PL_OPEN == stmt->get_type() || PL_OPEN_FOR == stmt->get_type())
8110
      ? static_cast<ObPLOpenStmt*>(stmt)->get_cursor()
8111
        : static_cast<ObPLCursorForLoopStmt*>(stmt)->get_cursor();
8112
  CK (OB_NOT_NULL(cursor));
8113
  CK (OB_NOT_NULL(resolve_ctx_.session_info_.get_pl_engine()));
8114
  CK (OB_NOT_NULL(stmt->get_namespace()));
8115
  if (OB_SUCC(ret) && NULL != parse_tree) {
8116
    OZ (resolve_cparams_expr(parse_tree, func, exprs));
8117
  }
8118
  if (OB_SUCC(ret)) {
8119
    const ObIArray<int64_t> &params_list = cursor->get_formal_params();
8120
    for (int64_t i = 0; OB_SUCC(ret) && i < params_list.count(); ++i) {
8121
      const ObPLVar *var = NULL;
8122
      if (cursor->is_package_cursor()) {
8123
        OZ (stmt->get_namespace()->get_package_var(resolve_ctx_,
8124
                                                   cursor->get_package_id(),
8125
                                                   params_list.at(i),
8126
                                                   var));
8127
        CK (OB_NOT_NULL(var));
8128
        OZ (iparams.push_back(const_cast<ObPLVar*>(var)));
8129
      } else if (cursor->get_routine_id() != stmt->get_namespace()->get_routine_id()) {
8130
        // not package cursor, not local cursor, must be subprogram cursor.
8131
        OZ (stmt->get_namespace()->get_subprogram_var(cursor->get_package_id(),
8132
                                                      cursor->get_routine_id(),
8133
                                                      params_list.at(i),
8134
                                                      var));
8135
        CK (OB_NOT_NULL(var));
8136
        OZ (iparams.push_back(const_cast<ObPLVar*>(var)));
8137
      } else {
8138
        OZ (iparams.push_back(const_cast<ObPLVar*>(stmt->get_variable((params_list.at(i))))));
8139
      }
8140
    }
8141
  }
8142
  OZ (resolve_cparams(exprs, iparams, stmt, func));
8143
  return ret;
8144
}
8145

8146
int ObPLResolver::resolve_open_for(
8147
  const ObStmtNodeTree *parse_tree, ObPLOpenForStmt *stmt, ObPLFunctionAST &func)
8148
{
8149
  int ret = OB_SUCCESS;
8150
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
8151
    ret = OB_INVALID_ARGUMENT;
8152
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
8153
  } else if (lib::is_mysql_mode()) {
8154
    ret = OB_ERR_UNEXPECTED;
8155
    LOG_WARN("mysql has no open for stmt", K(ret));
8156
  } else if (OB_FAIL(resolve_open(parse_tree, stmt, func))) {
8157
    LOG_WARN("failed to resolve open", K(parse_tree), K(stmt), K(current_block_), K(ret));
8158
  } else { //解析for
8159
    const ObStmtNodeTree *for_node = parse_tree->children_[2];
8160
    if (OB_ISNULL(for_node)) {
8161
      ret = OB_ERR_UNEXPECTED;
8162
      LOG_WARN("for clause is NULL", K(parse_tree->num_child_), K(ret));
8163
    } else {
8164
      if (T_SQL_STMT == for_node->type_) {
8165
        ObPLInto dummy_into(resolve_ctx_.allocator_);
8166
        if (OB_FAIL(resolve_static_sql(for_node, stmt->get_static_sql(), dummy_into, true/*is cursor*/, func))) {
8167
          LOG_WARN("failed to resolve static sql",  K(ret));
8168
        } else { //检查sql语句的结果集类型和Cursor的return类型是否兼容
8169
          const ObPLCursor *cursor = stmt->get_cursor();
8170
          CK (OB_NOT_NULL(cursor));
8171
          if (OB_SUCC(ret) && cursor->get_cursor_type().is_valid_type()) {
8172
            ObArenaAllocator allocator;
8173
            const ObUserDefinedType *cursor_type = NULL;
8174
            if (OB_FAIL(current_block_->get_namespace().get_user_type(cursor->get_cursor_type().get_user_type_id(),
8175
                  cursor_type, &allocator))) {
8176
              LOG_WARN("failed to get user type", K(cursor->get_cursor_type()), K(ret));
8177
            } else if (OB_ISNULL(cursor_type)) {
8178
              ret = OB_ERR_UNEXPECTED;
8179
              LOG_WARN("failed to get cursor type", K(cursor->get_cursor_type()), K(ret));
8180
            } else if (!cursor_type->is_record_type()) {
8181
              ret = OB_ERR_UNEXPECTED;
8182
              LOG_WARN("cursor must return record type", K(*cursor_type), K(ret));
8183
            } else if (OB_ISNULL(stmt->get_static_sql().get_row_desc())) {
8184
              ret = OB_ERR_UNEXPECTED;
8185
              LOG_WARN("static sql must has valid row desc", K(stmt->get_static_sql()), K(ret));
8186
            } else {
8187
              bool is_compatible = false;
8188
              const ObRecordType *return_type = static_cast<const ObRecordType*>(cursor_type);
8189
              if (OB_FAIL(stmt->get_static_sql().get_row_desc()->is_compatble(*return_type, is_compatible))) {
8190
                LOG_WARN("failed to check compatible", K(*stmt->get_static_sql().get_row_desc()), K(*return_type), K(ret));
8191
              } else if (!is_compatible) {
8192
                ret = OB_OBJ_TYPE_ERROR;
8193
                LOG_WARN("type not compatible", K(*stmt->get_static_sql().get_row_desc()), K(*return_type), K(ret));
8194
              } else { /*do nothing*/ }
8195
            }
8196
          }
8197
        }
8198
      } else { //expr
8199
        ObRawExpr *dynamic_sql_expr = NULL;
8200
        const ObPLCursor *cursor = stmt->get_cursor();
8201
        const ObPLVar *var = NULL;
8202
        if (OB_FAIL(stmt->get_var(var))) {
8203
          ret = OB_ERR_UNEXPECTED;
8204
          LOG_WARN("get var fail.", K(ret));
8205
        } else if (NULL == var || NULL == cursor) {
8206
          ret = OB_ERR_UNEXPECTED;
8207
          LOG_WARN("cursor or var is null.", K(ret));
8208
        } else if (cursor->get_cursor_type().is_valid_type()) {
8209
          ret = OB_ERR_CURSOR_IN_OPEN_DYNAMIC_SQL;
8210
          LOG_WARN("dynamicly can not OPEN a REF CURSOR that has RETURN type.", K(ret), K(var->get_name()));
8211
          LOG_USER_ERROR(OB_ERR_CURSOR_IN_OPEN_DYNAMIC_SQL, var->get_name().length(), var->get_name().ptr());
8212
        } else if (OB_FAIL(resolve_expr(for_node, func, dynamic_sql_expr,
8213
                                 combine_line_and_col(for_node->stmt_loc_)))) {
8214
          LOG_WARN("failed to resolve sql expr", K(ret));
8215
        } else if (!dynamic_sql_expr->get_result_type().is_string_or_lob_locator_type() && !dynamic_sql_expr->get_result_type().is_json()
8216
                   && !dynamic_sql_expr->get_result_type().is_geometry()) {
8217
          ret = OB_NOT_SUPPORTED;
8218
          LOG_WARN("dynamic sql must be string type", K(dynamic_sql_expr->get_result_type()), K(ret));
8219
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "non-string type dynamic sql");
8220
        } else {
8221
          stmt->set_dynamic_sql(func.get_expr_count() - 1);
8222
          func.set_modifies_sql_data();
8223
        }
8224
      }
8225
    }
8226
  }
8227

8228
  //解析using
8229
  if (OB_SUCC(ret)) {
8230
    const ObStmtNodeTree *using_node = parse_tree->children_[3];
8231
    if (NULL != using_node) {
8232
      OZ (resolve_using(using_node, stmt->get_using(), func));
8233
      if (OB_SUCC(ret) && stmt->has_out()) {
8234
        ret = OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY;
8235
        LOG_WARN("PLS-00254: OUT and IN/OUT modes cannot be used in this context Cause: \
8236
            actual parameter mode (OUT, or IN/OUT) is not used properly in USING clause.\
8237
            For USING clause in an OPEN statement, only IN mode is allowed.", K(ret));
8238
      }
8239
    }
8240
  }
8241
  return ret;
8242
}
8243

8244
int ObPLResolver::resolve_fetch(
8245
  const ObStmtNodeTree *parse_tree, ObPLFetchStmt *stmt, ObPLFunctionAST &func)
8246
{
8247
  int ret = OB_SUCCESS;
8248
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
8249
    ret = OB_INVALID_ARGUMENT;
8250
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
8251
  } else {
8252
    //解析name
8253
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
8254
    const ObPLCursor* cursor = NULL;
8255
    int64_t index = OB_INVALID_INDEX;
8256
    OZ (resolve_cursor(name_node, current_block_->get_namespace(), index, func));
8257
    CK (OB_NOT_NULL(current_block_->get_namespace().get_cursor_table()));
8258
    CK (OB_NOT_NULL(
8259
      cursor = current_block_->get_namespace().get_cursor_table()->get_cursor(index)));
8260
    OX (stmt->set_index(cursor->get_package_id(), cursor->get_routine_id(), cursor->get_index()));
8261
    if (OB_SUCC(ret)) {
8262
      if (cursor->is_for_update()) {
8263
        func.set_modifies_sql_data();
8264
      } else if (!func.is_modifies_sql_data()) {
8265
        func.set_reads_sql_data();
8266
      }
8267
    }
8268

8269
    //解析into
8270
    if (OB_SUCC(ret)) {
8271
      const ObStmtNodeTree *into_node = parse_tree->children_[1];
8272
      if (OB_ISNULL(into_node)) {
8273
        ret = OB_ERR_UNEXPECTED;
8274
        LOG_WARN("Fetch statement must have a INTO clause", K(ret));
8275
      } else if (OB_FAIL(resolve_into(into_node, *stmt, func))) {
8276
        LOG_WARN("resolve into node failed", K(parse_tree->children_), K(into_node), K(ret));
8277
      } else { /*do nothing*/ }
8278
      //检查Cursor的return类型和INTO子句类型是否兼容
8279
      if (OB_SUCC(ret) && lib::is_oracle_mode() && cursor->get_cursor_type().is_valid_type()) {
8280
        const ObUserDefinedType *cursor_type = NULL;
8281
        if (OB_FAIL(current_block_->get_namespace().get_user_type(
8282
            cursor->get_cursor_type().get_user_type_id(), cursor_type))) {
8283
          LOG_WARN("failed to get user type", K(cursor->get_cursor_type()), K(ret));
8284
        } else if (OB_ISNULL(cursor_type)) {
8285
          ret = OB_ERR_UNEXPECTED;
8286
          LOG_WARN("failed to get cursor type", K(cursor->get_cursor_type()), K(ret));
8287
        } else if (!cursor_type->is_record_type()) {
8288
          ret = OB_ERR_UNEXPECTED;
8289
          LOG_WARN("cursor must return record type", K(*cursor_type), K(ret));
8290
        } else {
8291
          bool is_compatible = true;
8292
          const ObRecordType *return_type = static_cast<const ObRecordType*>(cursor_type);
8293
          stmt->set_user_type(cursor_type);
8294
          if (return_type->get_record_member_count() != stmt->get_data_type().count()
8295
              && return_type->get_record_member_count() != stmt->get_into().count()) {
8296
            ret = OB_ERR_WRONG_FETCH_INTO_NUM;
8297
            LOG_WARN("wrong number of values in the INTO list of a FETCH statement", K(ret));
8298
          } else {
8299
            //如果into后面只有一个变量且为record类型，
8300
            bool has_type_record_type = false;
8301
            const ObPLDataType *into_var_type = NULL;
8302
            for (int64_t i = 0; OB_SUCC(ret) && !has_type_record_type && i < stmt->get_into_data_type().count(); ++i) {
8303
              into_var_type = &stmt->get_into_data_type(i);
8304
              //type定义的record
8305
              if (into_var_type->is_type_record()) {
8306
                has_type_record_type = true;
8307
              }
8308
            }
8309
            if (OB_SUCC(ret) && has_type_record_type && stmt->get_into_data_type().count() != 1) {
8310
              //后续新增494的错误码
8311
              ret = OB_ERR_MULTI_RECORD;
8312
              LOG_WARN("coercion into multiple record targets not supported", K(ret));
8313
            }
8314
            /* 走到这里如果没报错，有两种可能:
8315
               1.into变量只有唯一一个type record.
8316
               2.into变量无type record */
8317

8318
            if (OB_SUCC(ret)) {
8319
              const ObUserDefinedType *into_user_type = NULL;
8320
              const ObRecordType *into_record_type = NULL;
8321
              int64_t into_data_type_count = 0;
8322
              if (has_type_record_type) {
8323
                CK (1 == stmt->get_into_data_type().count());
8324
                OZ (current_block_->get_namespace().get_user_type(stmt->get_into_data_type(0).get_user_type_id(), into_user_type));
8325
                CK (OB_NOT_NULL(into_user_type));
8326
                CK (into_user_type->is_record_type());
8327
                OX (into_record_type = static_cast<const ObRecordType*>(into_user_type));
8328
                OX (into_data_type_count = into_record_type->get_record_member_count());
8329
              } else {
8330
                into_data_type_count = stmt->get_into_data_type().count();
8331
              }
8332
              // 依次比较cursor member和所有into变量
8333
              const ObPLDataType *left = NULL;
8334
              const ObPLDataType *right = NULL;
8335
              CK (return_type->get_record_member_count() == into_data_type_count);
8336
              for (int64_t i = 0; OB_SUCC(ret) && is_compatible && i < into_data_type_count; ++i) {
8337
                left = return_type->get_record_member_type(i);
8338
                if (has_type_record_type) {
8339
                  right = into_record_type->get_record_member_type(i);
8340
                } else {
8341
                  right = &stmt->get_into_data_type(i);
8342
                }
8343
                CK (OB_NOT_NULL(left));
8344
                if (OB_FAIL(ret)) {
8345
                } else if (left->is_obj_type() &&
8346
                           right->is_obj_type() &&
8347
                           NULL != right->get_data_type() &&
8348
                           !right->get_data_type()->get_meta_type().is_ext()) {
8349
                  if (right->get_data_type()->get_meta_type().is_null() &&
8350
                      stmt->get_into().count() > i &&
8351
                      is_question_mark_value(func.get_expr(stmt->get_into(i)), &(current_block_->get_namespace()))) {
8352
                    OZ (set_question_mark_type(
8353
                      func.get_expr(stmt->get_into(i)), &(current_block_->get_namespace()), left));
8354
                  } else {
8355
                    CK (OB_NOT_NULL(left->get_data_type()));
8356
                    OX (is_compatible = cast_supported(left->get_data_type()->get_obj_type(),
8357
                                                      left->get_data_type()->get_collation_type(),
8358
                                                      right->get_data_type()->get_obj_type(),
8359
                                                      right->get_data_type()->get_collation_type()));
8360
                  }
8361
                } else if ((!left->is_obj_type() ||
8362
                            (left->get_data_type() != NULL && left->get_data_type()->get_meta_type().is_ext()))
8363
                              &&
8364
                            (!right->is_obj_type() ||
8365
                            (right->get_data_type() != NULL && right->get_data_type()->get_meta_type().is_ext()))) {
8366
                  uint64_t left_udt_id = (NULL == left->get_data_type()) ? left->get_user_type_id()
8367
                                                                          : left->get_data_type()->get_udt_id();
8368
                  uint64_t right_udt_id = (NULL == right->get_data_type()) ? right->get_user_type_id()
8369
                                                                            : right->get_data_type()->get_udt_id();
8370
                  if (left_udt_id != right_udt_id) {
8371
                    is_compatible = false;
8372
                  } else {
8373
                    // same composite type, compatible is true, do nothing.
8374
                  }
8375
                } else {
8376
                  is_compatible = false;
8377
                }
8378
              }
8379

8380
              if (OB_SUCC(ret) && !is_compatible) {
8381
                ret = OB_ERR_TYPE_MISMATCH_IN_FETCH;
8382
                LOG_WARN("type not compatible", K(ret), KPC(left), KPC(right));
8383
              }
8384
            }
8385
          }
8386

8387
          if (OB_SUCC(ret) && !is_compatible) {
8388
            ret = OB_ERR_TYPE_MISMATCH_IN_FETCH;
8389
            LOG_WARN("type not compatible",
8390
                     K(*return_type),
8391
                     K(stmt->get_data_type()),
8392
                     K(stmt->get_into()),
8393
                     K(ret));
8394
          }
8395
        }
8396
      }
8397
    }
8398

8399
    //解析limit
8400
    if (OB_SUCC(ret) && 3 == parse_tree->num_child_) {
8401
      const ObStmtNodeTree *limit_node = parse_tree->children_[2];
8402
      if (!stmt->is_bulk()) {
8403
        ret = OB_ERR_LIMIT_ILLEGAL;
8404
        LOG_WARN("PLS-00439:A LIMIT clause must be used within a BULK FETCH", K(stmt->is_bulk()));
8405
      }
8406
      if (OB_SUCC(ret) && OB_ISNULL(limit_node)) {
8407
        stmt->set_limit(INT64_MAX);
8408
      }
8409
      if (OB_SUCC(ret) && OB_NOT_NULL(limit_node)) {
8410
        ObRawExpr *limit_expr = NULL;
8411
        ObPLDataType expected_type(ObIntType);
8412
        OZ (resolve_expr(limit_node, func, limit_expr,
8413
                         combine_line_and_col(limit_node->stmt_loc_), true, &expected_type, true));
8414
        if (OB_ERR_LIMIT_CLAUSE == ret) {
8415
          LOG_USER_ERROR(OB_ERR_LIMIT_CLAUSE, static_cast<int>(limit_node->str_len_),
8416
                         limit_node->str_value_);
8417
        } else if (OB_ERR_EXPRESSION_WRONG_TYPE == ret) {
8418
          LOG_WARN("expression is of wrong type", K(ret), K(limit_node->str_value_));
8419
        } else {
8420
          // do nothing
8421
        }
8422
        CK (OB_NOT_NULL(limit_expr));
8423
        OX (stmt->set_limit(func.get_expr_count() - 1));
8424
      }
8425
    }
8426
  }
8427
  return ret;
8428
}
8429

8430
int ObPLResolver::resolve_close(
8431
  const ObStmtNodeTree *parse_tree, ObPLCloseStmt *stmt, ObPLFunctionAST &func)
8432
{
8433
  int ret = OB_SUCCESS;
8434
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
8435
    ret = OB_INVALID_ARGUMENT;
8436
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
8437
  } else {
8438
    //解析name
8439
    const ObStmtNodeTree *name_node = parse_tree->children_[0];
8440
    int64_t index = OB_INVALID_INDEX;
8441
    const ObPLCursor *cursor = NULL;
8442
    OZ (resolve_cursor(name_node, current_block_->get_namespace(), index, func));
8443
    CK (OB_NOT_NULL(current_block_->get_namespace().get_cursor_table()));
8444
    CK (OB_NOT_NULL(
8445
      cursor = current_block_->get_namespace().get_cursor_table()->get_cursor(index)));
8446
    OX (stmt->set_index(
8447
      cursor->get_package_id(), cursor->get_routine_id(), cursor->get_index()));
8448
    if (OB_SUCC(ret)) {
8449
      if (cursor->is_for_update()) {
8450
        func.set_modifies_sql_data();
8451
      } else if (!func.is_modifies_sql_data()) {
8452
        func.set_reads_sql_data();
8453
      }
8454
    }
8455
  }
8456
  return ret;
8457
}
8458

8459
int ObPLResolver::resolve_null(const ObStmtNodeTree *parse_tree, ObPLNullStmt *stmt, ObPLFunctionAST &func)
8460
{
8461
  UNUSEDx(parse_tree, stmt, func);
8462
  return OB_SUCCESS;
8463
}
8464

8465

8466
int ObPLResolver::resolve_pipe_row(
8467
  const ObStmtNodeTree *parse_tree, ObPLPipeRowStmt *stmt, ObPLFunctionAST &func)
8468
{
8469
  int ret = OB_SUCCESS;
8470
#ifdef OB_BUILD_ORACLE_PL
8471
  ObRawExpr *row_expr = NULL;
8472
  CK (OB_NOT_NULL(parse_tree));
8473
  CK (T_SP_PIPE_ROW == parse_tree->type_);
8474
  CK (1 == parse_tree->num_child_);
8475
  CK (OB_NOT_NULL(parse_tree->children_[0]));
8476
  if (OB_SUCC(ret) && !func.get_pipelined()) {
8477
    ret = OB_ERR_PIPE_STMT_IN_NON_PIPELINED_FUNC;
8478
    LOG_WARN("PLS-00629: PIPE statement cannot be used in non-pipelined functions", K(ret));
8479
  }
8480
  const ObPLDataType *return_type = &(func.get_ret_type());
8481
  const ObUserDefinedType* user_type = NULL;
8482
  const ObCollectionType* coll_type = NULL;
8483
  CK (OB_NOT_NULL(return_type));
8484
  CK (OB_NOT_NULL(current_block_));
8485
  OZ (current_block_->
8486
    get_namespace().get_pl_data_type_by_id(return_type->get_user_type_id(), user_type));
8487
  CK (OB_NOT_NULL(user_type));
8488
  CK (user_type->is_collection_type());
8489
  CK (OB_NOT_NULL(coll_type = static_cast<const ObCollectionType*>(user_type)));
8490
  CK (return_type->is_collection_type());
8491
  OZ (resolve_expr(
8492
    parse_tree->children_[0], func, row_expr,
8493
    combine_line_and_col(parse_tree->children_[0]->stmt_loc_),
8494
    true, &(coll_type->get_element_type())));
8495
  CK (OB_NOT_NULL(row_expr));
8496
  CK (OB_NOT_NULL(stmt));
8497
  OX (stmt->set_row(func.get_expr_count() - 1));
8498
  OX (stmt->set_type(func.get_ret_type()));
8499
#else
8500
  UNUSEDx(parse_tree, stmt, func);
8501
#endif
8502
  return ret;
8503
}
8504

8505
int ObPLResolver::resolve_ident(const ParseNode *node, ObString &ident)
8506
{
8507
  int ret = OB_SUCCESS;
8508
  if (OB_ISNULL(node)) {
8509
    ret = OB_ERR_UNEXPECTED;
8510
    LOG_WARN("Invalid Argument", K(node), K(ret));
8511
  } else if (T_IDENT != node->type_) {
8512
    ret = OB_ERR_UNEXPECTED;
8513
    LOG_WARN("Invalid ident", K(node->type_), K(ret));
8514
  } else if (OB_UNLIKELY(node->str_len_ > 
8515
    (lib::is_oracle_mode() ? OB_MAX_PL_IDENT_LENGTH : OB_MAX_MYSQL_PL_IDENT_LENGTH))) {
8516
    ret = OB_ERR_TOO_LONG_IDENT;
8517
    LOG_WARN("identifier is too long", K(node->str_value_), K(ret));
8518
  } else {
8519
    ident.assign_ptr(node->str_value_, static_cast<int32_t>(node->str_len_));
8520
  }
8521
  return ret;
8522
}
8523

8524
bool ObPLResolver::is_need_add_checker(const ObPLIntegerType &type, const ObRawExpr *expr)
8525
{
8526
  bool ret = true;
8527
  // for simple_integer, if checker expr tree already has checker, do not add.
8528
  // others always add.
8529
  if (PL_SIMPLE_INTEGER == type && OB_NOT_NULL(expr)) {
8530
    if (T_FUN_PL_INTEGER_CHECKER == expr->get_expr_type()) {
8531
      ret = false;
8532
    } else {
8533
      for (int i = 0; ret && i < expr->get_param_count(); ++i) {
8534
        ret = is_need_add_checker(type, expr->get_param_expr(i));
8535
      }
8536
    }
8537
  }
8538
  return ret;
8539
}
8540

8541
int ObPLResolver::add_pl_integer_checker_expr(ObRawExprFactory &expr_factory,
8542
                                              const ObPLIntegerType &type,
8543
                                              int32_t lower,
8544
                                              int32_t upper,
8545
                                              ObRawExpr *&expr)
8546
{
8547
  int ret = OB_SUCCESS;
8548
  CK(OB_NOT_NULL(expr));
8549
  if (OB_SUCC(ret)) {
8550
    ObPLIntegerCheckerRawExpr *checker = NULL;
8551
    if (expr_factory.create_raw_expr(T_FUN_PL_INTEGER_CHECKER, checker)) {
8552
      LOG_WARN("create pl_integer_checker failed", K(ret));
8553
    } else if (OB_ISNULL(checker)) {
8554
      ret = OB_ERR_UNEXPECTED;
8555
      LOG_WARN("new raw expr is NULL", K(checker), K(ret));
8556
    } else if (OB_FAIL(checker->add_param_expr(expr))) {
8557
      LOG_WARN("add real param expr failed", K(ret));
8558
    } else {
8559
      checker->set_pl_integer_type(type);
8560
      checker->set_range(lower, upper);
8561
      expr = checker;
8562
    }
8563
  }
8564
  return ret;
8565
}
8566

8567
int ObPLResolver::check_expr_result_type(const ObRawExpr *expr, ObPLIntegerType &pl_integer_type, bool &is_anonymos_arg)
8568
{
8569
  int ret = OB_SUCCESS;
8570
  CK(OB_NOT_NULL(expr));
8571
  if (OB_SUCC(ret)) {
8572
    pl_integer_type = PL_INTEGER_INVALID;
8573
    if (T_FUN_PL_INTEGER_CHECKER == expr->get_expr_type()) {
8574
      const ObPLIntegerCheckerRawExpr *checker = static_cast<const ObPLIntegerCheckerRawExpr*>(expr);
8575
      CK (OB_NOT_NULL(checker));
8576
      OX (pl_integer_type = checker->get_pl_integer_type());
8577
    } else if (T_OBJ_ACCESS_REF == expr->get_expr_type()) {
8578
      ObPLDataType pl_data_type;
8579
      const ObObjAccessRawExpr *obj_expr = static_cast<const ObObjAccessRawExpr*>(expr);
8580
      if (OB_FAIL(obj_expr->get_final_type(pl_data_type))) {
8581
        LOG_WARN("failed to get obj access raw expr final type", K(ret));
8582
      } else if (pl_data_type.is_pl_integer_type()) {
8583
        pl_integer_type = pl_data_type.get_pl_integer_type();
8584
      }
8585
    } else if (expr->is_const_raw_expr()) {
8586
      const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(expr);
8587
      const ObPLSymbolTable* symbol_table = NULL;
8588
      const ObPLVar* var = NULL;
8589
      if (T_QUESTIONMARK != const_expr->get_expr_type()) {
8590
        /* Integer Literals in SIMPLE_INTEGER Range
8591
         * Integer literals in the SIMPLE_INTEGER range have the data type SIMPLE_INTEGER.
8592
         * However, to ensure backward compatibility, when all operands in an arithmetic
8593
         * expression are integer literals, PL/SQL treats the integer literals as if they were cast to
8594
         * PLS_INTEGER. */
8595
        if (T_INT == const_expr->get_expr_type()) {
8596
          const ObObj &obj = const_expr->get_value();
8597
          int64_t v = 0;
8598
          if (obj.is_integer_type()) {
8599
            v = obj.get_int();
8600
          } else if (obj.is_number()) {
8601
            OZ (obj.get_number().extract_valid_int64_with_trunc(v));
8602
          }
8603
          if (OB_SUCC(ret) && v >= -2147483648 && v <= 2147483647) {
8604
            pl_integer_type = PL_SIMPLE_INTEGER;
8605
          }
8606
        }
8607
      } else if (!const_expr->get_value().is_unknown()) {
8608
        ret = OB_ERR_UNEXPECTED;
8609
        LOG_WARN("Unexpected const expr", K(const_expr->get_value()), K(current_block_), K(ret));
8610
      } else if (OB_ISNULL(current_block_) || OB_ISNULL(symbol_table = current_block_->get_symbol_table())) {
8611
        ret = OB_ERR_UNEXPECTED;
8612
        LOG_WARN("unexpected null", K(current_block_), K(ret));
8613
      } else if (OB_ISNULL(var = symbol_table->get_symbol(const_expr->get_value().get_unknown()))) {
8614
        ret = OB_ERR_UNEXPECTED;
8615
        LOG_WARN("get symble var is null", K(var), K(const_expr->get_value().get_unknown()), K(ret));
8616
      } else {
8617
        if (0 == var->get_name().case_compare(ObPLResolver::ANONYMOUS_ARG)) {
8618
          is_anonymos_arg = true;
8619
        }
8620
        pl_integer_type = var->get_type().get_pl_integer_type();
8621
      }
8622
    } else if (expr->is_udf_expr()) {
8623
      const ObUDFRawExpr *udf = static_cast<const ObUDFRawExpr *>(expr);
8624
      CK (OB_NOT_NULL(udf));
8625
      OX (pl_integer_type = udf->get_pls_type());
8626
    }
8627
  }
8628
  return ret;
8629
}
8630

8631
int ObPLResolver::add_pl_integer_checker_expr(ObRawExprFactory &expr_factory,
8632
                                              ObRawExpr *&expr,
8633
                                              bool &need_replace)
8634
{
8635
  int ret = OB_SUCCESS;
8636
  ObRawExpr *child = NULL;
8637
  need_replace = false;
8638
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
8639
    child = expr->get_param_expr(i);
8640
    if (OB_ISNULL(child)) {
8641
      ret = OB_ERR_UNEXPECTED;
8642
      LOG_WARN("child expr is null", K(ret));
8643
    } else if (OB_FAIL(add_pl_integer_checker_expr(expr_factory, child, need_replace))) {
8644
      LOG_WARN("failed to add pl integer checker expr", K(ret));
8645
    } else if (need_replace) {
8646
      expr->get_param_expr(i) = child;
8647
    }
8648
  }
8649
  #define LOGIC_EXPR(expr) \
8650
  ( T_OP_IN == expr->get_expr_type() \
8651
    || T_OP_EXISTS == expr->get_expr_type() \
8652
    || T_OP_NOT_IN == expr->get_expr_type() \
8653
    || T_OP_NOT_EXISTS == expr->get_expr_type() \
8654
    || T_OP_ROW == expr->get_expr_type() \
8655
   )
8656

8657
  #define CHECK_RES_TYPE(expr) \
8658
  ( \
8659
     expr->get_result_type().is_numeric_type()\
8660
  )
8661
  if (OB_SUCC(ret)) {
8662
    // 对于溢出的检查只关心双目运算符的计算
8663
    if (2 == expr->get_param_count() && !IS_COMMON_COMPARISON_OP(expr->get_expr_type())
8664
             && !LOGIC_EXPR(expr) && expr->get_expr_type() != T_FUN_SYS_POWER && CHECK_RES_TYPE(expr)) {
8665
      const ObRawExpr *left = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(0));
8666
      const ObRawExpr *right = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(1));
8667
      ObPLIntegerType left_pl_integer = PL_INTEGER_INVALID, right_pl_integer = PL_INTEGER_INVALID;
8668
      bool is_anonymos_arg_left = false;
8669
      bool is_anonymos_arg_right = false;
8670
      if (OB_FAIL(check_expr_result_type(left, left_pl_integer, is_anonymos_arg_left))) {
8671
        LOG_WARN("failed to check expr result type", K(ret));
8672
      } else if (OB_FAIL(check_expr_result_type(right, right_pl_integer, is_anonymos_arg_right))) {
8673
        LOG_WARN("failed to check expr result type", K(ret));
8674
      } else if (PL_INTEGER_INVALID != left_pl_integer && PL_INTEGER_INVALID != right_pl_integer) {
8675
        ObPLIntegerType type = PL_SIMPLE_INTEGER == left_pl_integer && PL_SIMPLE_INTEGER == right_pl_integer ?
8676
                          PL_SIMPLE_INTEGER : PL_PLS_INTEGER;
8677
        /* Integer Literals in SIMPLE_INTEGER Range
8678
           Integer literals in the SIMPLE_INTEGER range have the data type SIMPLE_INTEGER.
8679
           However, to ensure backward compatibility, when all operands in an arithmetic
8680
           expression are integer literals, PL/SQL treats the integer literals as if they were cast to
8681
           PLS_INTEGER. */
8682
        if (PL_SIMPLE_INTEGER == type &&
8683
            ((T_INT == left->get_expr_type() && T_INT == right->get_expr_type()) ||
8684
             (is_anonymos_arg_left && is_anonymos_arg_right))) {
8685
          type = PL_PLS_INTEGER;
8686
        }
8687
        OZ (add_pl_integer_checker_expr(expr_factory, type, -2147483648, 2147483647, expr));
8688
        OX (need_replace = true);
8689
      }
8690
    }
8691
  }
8692
  #undef LOGIC_EXPR
8693
  #undef CHECK_RES_TYPE
8694
  return ret;
8695
}
8696

8697
int ObPLResolver::resolve_condition_compile(
8698
  ObIAllocator &allocator,
8699
  ObSQLSessionInfo *session_info,
8700
  ObSchemaGetterGuard *schema_guard,
8701
  ObPLPackageGuard *package_guard,
8702
  ObMySQLProxy *sql_proxy,
8703
  const ObString *exec_env,
8704
  const ParseNode *node,
8705
  const ParseNode *&new_node,
8706
  bool is_inner_parse,
8707
  bool is_for_trigger,
8708
  bool is_for_dynamic,
8709
  bool *is_include_old_new_in_trigger,
8710
  ObPLDependencyTable *dep_table)
8711
{
8712
  int ret = OB_SUCCESS;
8713
  ObRawExprFactory expr_factory(allocator);
8714
  CK (OB_NOT_NULL(node));
8715
  CK (T_SP_PRE_STMTS == node->type_);
8716
  CK (OB_NOT_NULL(schema_guard));
8717
  if (OB_SUCC(ret) && OB_ISNULL(sql_proxy)) {
8718
    CK (OB_NOT_NULL(sql_proxy = GCTX.sql_proxy_));
8719
  }
8720
  if (OB_FAIL(ret)) {
8721
  } else if (OB_ISNULL(session_info)) {
8722
    ObPLPackageGuard local_pkg_guard(schema_guard->get_tenant_id());
8723
    if (OB_SUCC(ret) && OB_ISNULL(package_guard)) {
8724
      OZ (local_pkg_guard.init());
8725
      OX (package_guard = &local_pkg_guard);
8726
    }
8727
    SMART_VAR(sql::ObSQLSessionInfo, session) {
8728
      ObExecEnv env;
8729
      CK (OB_NOT_NULL(exec_env));
8730
      OZ (env.init(*exec_env));
8731
      OZ (session.init(0, 0, &allocator));
8732
      OZ (session.load_default_sys_variable(false, false));
8733
      OZ (env.store(session));
8734
      if (OB_SUCC(ret)) {
8735
        ObPLResolver resolver(
8736
          allocator, session,
8737
          *schema_guard, *package_guard, *sql_proxy, expr_factory, NULL, false);
8738
        int64_t question_mark_count = 0;
8739
        OZ (resolver.resolve_condition_compile(
8740
          node,
8741
          new_node,
8742
          question_mark_count,
8743
          is_inner_parse,
8744
          is_for_trigger,
8745
          is_for_dynamic,
8746
          is_include_old_new_in_trigger,
8747
          dep_table));
8748
      }
8749
    }
8750
  } else {
8751
    ObPLPackageGuard local_pkg_guard(session_info->get_effective_tenant_id());
8752
    if (OB_SUCC(ret) && OB_ISNULL(package_guard)) {
8753
      OZ (local_pkg_guard.init());
8754
      OX (package_guard = &local_pkg_guard);
8755
    }
8756
    ObPLResolver resolver(
8757
      allocator, *session_info,
8758
      *schema_guard, *package_guard, *sql_proxy, expr_factory, NULL, false);
8759
    int64_t question_mark_count = 0;
8760
    OZ (resolver.resolve_condition_compile(
8761
      node,
8762
      new_node,
8763
      question_mark_count,
8764
      is_inner_parse,
8765
      is_for_trigger,
8766
      is_for_dynamic,
8767
      is_include_old_new_in_trigger,
8768
      dep_table));
8769
  }
8770
  return ret;
8771
}
8772

8773
int ObPLResolver::resolve_condition_compile(
8774
  const ParseNode *node,
8775
  const ParseNode *&new_node,
8776
  int64_t &question_mark_count,
8777
  bool is_inner_parse,
8778
  bool is_for_trigger,
8779
  bool is_for_dynamic,
8780
  bool *is_include_old_new_in_trigger,
8781
  ObPLDependencyTable *dep_table)
8782
{
8783
  int ret = OB_SUCCESS;
8784
  ObString old_sql;
8785
  ObString new_sql;
8786
  ObPLParser pl_parser(
8787
    resolve_ctx_.allocator_, resolve_ctx_.session_info_.get_charsets4parser(),
8788
    resolve_ctx_.session_info_.get_sql_mode());
8789
  ParseResult parse_result;
8790

8791
  HEAP_VAR(ObPLFunctionAST, unit_ast, resolve_ctx_.allocator_) {
8792
    CK (OB_NOT_NULL(node));
8793
    OZ (init(unit_ast));
8794
    OZ (resolve_condition_compile(unit_ast, *node, old_sql, new_sql));
8795
    CK (OB_LIKELY(old_sql.length() == new_sql.length()));
8796

8797
    OX (parse_result.is_for_trigger_ = is_for_trigger ? 1 : 0);
8798
    OX (parse_result.is_dynamic_sql_ = is_for_dynamic ? 1 : 0);
8799
    parse_result.mysql_compatible_comment_ = 0;
8800
    OZ (pl_parser.parse(new_sql, old_sql, parse_result, is_inner_parse));
8801
    if (OB_SUCC(ret) && OB_NOT_NULL(is_include_old_new_in_trigger)) {
8802
      *is_include_old_new_in_trigger = parse_result.is_include_old_new_in_trigger_;
8803
    }
8804

8805
    CK (1 == parse_result.result_tree_->num_child_);
8806
    CK (OB_NOT_NULL(new_node = parse_result.result_tree_->children_[0]));
8807
    OX (question_mark_count = parse_result.question_mark_ctx_.count_);
8808
    if (OB_SUCC(ret) && T_SP_CREATE_TYPE == new_node->type_) {
8809
      ret = OB_ERR_DIRECTIVE_CONTEXT;
8810
      LOG_WARN("preprocessor directives are not supported in this context",
8811
              K(ret), K(new_node->type_));
8812
    }
8813
    if (OB_SUCC(ret) && OB_NOT_NULL(dep_table)) {
8814
      ObPLDependencyTable &src_table = unit_ast.get_dependency_table();
8815
      for (int i = 0; OB_SUCC(ret) && i < src_table.count(); ++i) {
8816
        OZ (add_var_to_array_no_dup(*dep_table, src_table.at(i)));
8817
      }
8818
    }
8819
  }
8820
  return ret;
8821
}
8822

8823
int ObPLResolver::replace_source_string(
8824
  const ObString &old_sql, ParseNode *new_node)
8825
{
8826
  int ret = OB_SUCCESS;
8827
  if (OB_NOT_NULL(new_node)) {
8828
    if (new_node->str_len_ > 0 && new_node->pl_str_off_ >= 0) {
8829
      new_node->str_value_ = parse_strndup(old_sql.ptr() + new_node->pl_str_off_,
8830
                                           new_node->str_len_,
8831
                                           &resolve_ctx_.allocator_);
8832
    }
8833
    for (int64_t i = 0; OB_SUCC(ret) && i < new_node->num_child_; ++i) {
8834
      OZ (replace_source_string(old_sql, new_node->children_[i]));
8835
    }
8836
  }
8837
  return ret;
8838
}
8839

8840
int ObPLResolver::resolve_condition_compile(
8841
  ObPLFunctionAST &unit_ast, const ParseNode &node, ObString &old_sql, ObString &new_sql)
8842
{
8843
  int ret = OB_SUCCESS;
8844
  int64_t start = -1;
8845
  int64_t end = -1;
8846
  char* ptr = NULL;
8847
  const ParseNode *child = NULL;
8848

8849
  CK (OB_NOT_NULL(child = &node));
8850
  CK (OB_LIKELY(T_SP_PRE_STMTS == child->type_));
8851
  OX (old_sql.assign_ptr(child->str_value_, child->str_len_));
8852
  if (OB_FAIL(ret)) {
8853
  } else if (OB_ISNULL(
8854
        ptr = static_cast<char*>(resolve_ctx_.allocator_.alloc(old_sql.length() + 1)))) {
8855
    ret = OB_ALLOCATE_MEMORY_FAILED;
8856
    LOG_WARN("failed to alloc memory for new sql string", K(ret));
8857
  } else {
8858
    MEMSET(ptr, ' ', old_sql.length());
8859
    ptr[old_sql.length()] = '\0';
8860
  }
8861
  OX (new_sql.assign_buffer(ptr, old_sql.length() + 1));
8862
  OX (new_sql.set_length(old_sql.length()));
8863

8864
  LOG_INFO("resolve condition compile : old_sql is ", K(old_sql));
8865
  OZ (resolve_preprocess_stmt(unit_ast, *child, old_sql, new_sql, start, end));
8866
  if (OB_FAIL(ret)) {
8867
  } else if ((end + 1) < old_sql.length()) {
8868
    OZ (append_sql(old_sql, new_sql, end + 1, old_sql.length()));
8869
  }
8870

8871
  LOG_INFO("resolve condition compile : after condition compile",
8872
           K(ret), K(old_sql), K(new_sql), K(start), K(end));
8873
  return ret;
8874
}
8875

8876
int ObPLResolver::append_sql(
8877
  ObString &old_sql, ObString &new_sql, int64_t start, int64_t end, bool fill_blank)
8878
{
8879
  int ret = OB_SUCCESS;
8880
  if (end < start) {
8881
    // do nothing ...
8882
  } else {
8883
    for (int64_t i = start; OB_SUCC(ret) && i <= end; ++i) {
8884
      if (!fill_blank) {
8885
        new_sql.ptr()[i] = old_sql[i];
8886
      } else if (old_sql[i] == '\t' || old_sql[i] == '\n') {
8887
        new_sql.ptr()[i] = old_sql[i];
8888
      } else {
8889
        new_sql.ptr()[i] = ' ';
8890
      }
8891
    }
8892
  }
8893
  LOG_INFO("append_sql done!",
8894
           K(old_sql), K(new_sql), K(start), K(end), K(fill_blank),
8895
           K(old_sql.length()));
8896
  return ret;
8897
}
8898

8899
int ObPLResolver::resolve_preprocess_stmt(
8900
  ObPLFunctionAST &unit_ast,
8901
  const ParseNode &node, ObString &old_sql, ObString &new_sql, int64_t &start, int64_t &end)
8902
{
8903
  int ret = OB_SUCCESS;
8904
  CK (OB_LIKELY(T_SP_PRE_STMTS == node.type_));
8905
  for (int64_t i = 0; OB_SUCC(ret) && i < node.num_child_; ++i) {
8906
    const ParseNode* child = node.children_[i];
8907
    if (OB_ISNULL(child)) {
8908
      ret = OB_ERR_UNEXPECTED;
8909
      LOG_WARN("child node is null!", K(ret), K(child), K(i));
8910
    } else if (T_IDENT == child->type_) {
8911
      if (-1 == start) {
8912
        start = child->int32_values_[0];
8913
        end = child->int32_values_[1];
8914
        OZ (append_sql(old_sql, new_sql, child->int32_values_[0], child->int32_values_[1]));
8915
      } else {
8916
        CK ((end + 1) <= child->int32_values_[0]);
8917
        OZ (append_sql(old_sql, new_sql, end + 1, child->int32_values_[0], true));
8918
        OZ (append_sql(old_sql, new_sql, child->int32_values_[0], child->int32_values_[1]));
8919
        OX (start = child->int32_values_[0]);
8920
        OX (end = child->int32_values_[1]);
8921
      }
8922
    } else if (T_SP_ERROR == child->type_) {
8923
      OZ (SMART_CALL(resolve_error_stmt(unit_ast, *child)));
8924
    } else if (T_SP_PRE_IF == child->type_) {
8925
      OZ (SMART_CALL(resolve_pre_if_stmt(unit_ast, *child, old_sql, new_sql, start, end)));
8926
    } else if (T_SP_PRE_STMTS == child->type_) {
8927
      OZ (SMART_CALL(resolve_preprocess_stmt(unit_ast, *child, old_sql, new_sql, start, end)));
8928
    } else {
8929
      ret = OB_ERR_UNEXPECTED;
8930
      LOG_WARN("unexpected node type!", K(ret), K(child->type_));
8931
    }
8932
  }
8933
  return ret;
8934
}
8935

8936
int ObPLResolver::resolve_error_stmt(ObPLFunctionAST &unit_ast, const ParseNode &node)
8937
{
8938
  int ret = OB_SUCCESS;
8939
  ObObj result;
8940
  ObString result_msg;
8941
  CK (OB_LIKELY(T_SP_ERROR == node.type_));
8942
  CK (OB_LIKELY(1 == node.num_child_));
8943
  CK (OB_NOT_NULL(node.children_[0]));
8944

8945
  OZ (resolve_and_calc_static_expr(unit_ast, *(node.children_[0]), ObVarcharType, result));
8946
  OZ (result.get_string(result_msg));
8947
  if (OB_SUCC(ret)) {
8948
    ret = OB_ERR_DIRECTIVE_ERROR;
8949
    LOG_WARN("$ERROR directive was used. This is an expected error message.", K(ret), K(result));
8950
    LOG_USER_ERROR(OB_ERR_DIRECTIVE_ERROR, result_msg.length(), result_msg.ptr());
8951
  }
8952
  return ret;
8953
}
8954

8955
int ObPLResolver::resolve_pre_if_stmt(ObPLFunctionAST &unit_ast,
8956
                                      const ParseNode &node,
8957
                                      ObString &old_sql,
8958
                                      ObString &new_sql,
8959
                                      int64_t &start,
8960
                                      int64_t &end)
8961
{
8962
  int ret = OB_SUCCESS;
8963

8964
  const ParseNode *bool_expr_node = NULL;
8965
  const ParseNode *then_expr_node = NULL;
8966
  const ParseNode *else_expr_node = NULL;
8967
  ObObj result;
8968

8969
  CK (T_SP_PRE_IF == node.type_);
8970
  CK (3 == node.num_child_);
8971
  CK (OB_NOT_NULL(bool_expr_node = node.children_[0]));
8972
  CK (OB_NOT_NULL(then_expr_node = node.children_[1]));
8973
  OX (else_expr_node = node.children_[2]);
8974

8975
  // Step1. resolve bool expr and calc result.
8976
  OZ (resolve_and_calc_static_expr(unit_ast, *bool_expr_node, ObTinyIntType, result));
8977

8978
  // Step2. concat sql string acording bool result.
8979
  if (OB_FAIL(ret)) {
8980
  } else if (result.is_true()) {
8981
    OZ (resolve_preprocess_stmt(unit_ast, *then_expr_node, old_sql, new_sql, start, end));
8982
  } else if (OB_NOT_NULL(else_expr_node)) {
8983
    OZ (resolve_pre_else_stmt(unit_ast, *else_expr_node, old_sql, new_sql, start, end));
8984
  }
8985
  return ret;
8986
}
8987

8988
int ObPLResolver::resolve_pre_else_stmt(ObPLFunctionAST &unit_ast,
8989
                                        const ParseNode &node,
8990
                                        ObString &old_sql,
8991
                                        ObString &new_sql,
8992
                                        int64_t &start,
8993
                                        int64_t &end)
8994
{
8995
  int ret = OB_SUCCESS;
8996
  CK (OB_LIKELY(1 == node.num_child_));
8997
  CK (OB_NOT_NULL(node.children_));
8998
  CK (OB_NOT_NULL(node.children_[0]));
8999
  CK (OB_LIKELY(T_SP_PRE_IF == node.children_[0]->type_
9000
                || T_SP_PRE_STMTS == node.children_[0]->type_));
9001
  if (OB_FAIL(ret)) {
9002
  } else if (T_SP_PRE_IF == node.children_[0]->type_) {
9003
    OZ (resolve_pre_if_stmt(unit_ast, *(node.children_[0]), old_sql, new_sql, start, end));
9004
  } else {
9005
    CK (T_SP_PRE_STMTS == node.children_[0]->type_);
9006
    OZ (resolve_preprocess_stmt(unit_ast, *(node.children_[0]), old_sql, new_sql, start, end));
9007
  }
9008
  return ret;
9009
}
9010

9011
// ----------------- check boolean static expr -------------
9012

9013
int ObPLResolver::is_bool_literal_expr(const ObRawExpr *expr, bool &is_bool_literal_expr)
9014
{
9015
  int ret = OB_SUCCESS;
9016
  CK (OB_NOT_NULL(expr));
9017
  OX (is_bool_literal_expr
9018
        = (T_NULL == expr->get_expr_type()
9019
            || T_BOOL == expr->get_expr_type()
9020
            || (T_FUN_PLSQL_VARIABLE == expr->get_expr_type()
9021
                && ObNullType == expr->get_result_type().get_type())));
9022
  return ret;
9023
}
9024

9025
int ObPLResolver::is_static_expr(const ObRawExpr *expr, bool &is_static_expr)
9026
{
9027
  int ret = OB_SUCCESS;
9028
  CK (OB_NOT_NULL(expr));
9029
  if (OB_FAIL(ret)) {
9030
  } else if (T_OP_GET_PACKAGE_VAR == expr->get_expr_type()) {
9031
    const ObSysFunRawExpr *f_expr = static_cast<const ObSysFunRawExpr *>(expr);
9032
    uint64_t package_id = OB_INVALID_ID;
9033
    uint64_t var_idx = OB_INVALID_ID;
9034
    CK (OB_NOT_NULL(f_expr) && f_expr->get_param_count() >= 2);
9035
    OZ (get_const_expr_value(f_expr->get_param_expr(0), package_id));
9036
    OZ (get_const_expr_value(f_expr->get_param_expr(1), var_idx));
9037
    OZ (check_package_variable_read_only(package_id, var_idx));
9038
    if (OB_ERR_VARIABLE_IS_READONLY == ret) {
9039
      ret = OB_SUCCESS;
9040
      is_static_expr = true;
9041
    }
9042
  } else if (T_FUN_PLSQL_VARIABLE == expr->get_expr_type()) {
9043
    is_static_expr = true;
9044
  }
9045
  return ret;
9046
}
9047

9048
int ObPLResolver::is_static_bool_expr(const ObRawExpr *expr, bool &is_static_bool_expr)
9049
{
9050
  int ret = OB_SUCCESS;
9051
  CK (OB_NOT_NULL(expr));
9052
  OX (is_static_bool_expr = false);
9053
  if (OB_SUCC(ret)
9054
      && ObTinyIntType == expr->get_result_type().get_type()) {
9055
    OZ (is_static_expr(expr, is_static_bool_expr));
9056
  }
9057
  return ret;
9058
}
9059

9060
int ObPLResolver::is_pls_literal_expr(const ObRawExpr *expr, bool &is_pls_literal_expr)
9061
{
9062
  int ret = OB_SUCCESS;
9063
  CK (OB_NOT_NULL(expr));
9064
  OX (is_pls_literal_expr = (T_NULL == expr->get_expr_type()));
9065
  if (OB_SUCC(ret)
9066
      && !is_pls_literal_expr
9067
      && T_INT == expr->get_expr_type()) {
9068
    const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr *>(expr);
9069
    const ObObj &obj = const_expr->get_value();
9070
    int64_t v = 0;
9071
    if (obj.is_integer_type()) {
9072
      v = obj.get_int();
9073
    } else if (obj.is_number()) {
9074
      OZ (obj.get_number().extract_valid_int64_with_trunc(v));
9075
    }
9076
    if (OB_SUCC(ret) && v >= -2147483648 && v <= 2147483647) {
9077
      is_pls_literal_expr = true;
9078
    }
9079
  }
9080
  return ret;
9081
}
9082

9083
int ObPLResolver::is_static_pls_expr(const ObRawExpr *expr, bool &is_static_pls_expr)
9084
{
9085
  int ret = OB_SUCCESS;
9086
  CK (OB_NOT_NULL(expr));
9087
  OX (is_static_pls_expr = false);
9088
  if (OB_FAIL(ret)) {
9089
  } else if (OB_FAIL(is_pls_literal_expr(expr, is_static_pls_expr))) {
9090
    LOG_WARN("failed to call is_pls_literal_expr", K(ret), KPC(expr));
9091
  } else if (!is_static_pls_expr) {
9092
    if (OB_FAIL(is_static_expr(expr, is_static_pls_expr))) {
9093
      LOG_WARN("failed to call is_static_expr", K(ret), KPC(expr));
9094
    } else if (is_static_pls_expr && ObInt32Type != expr->get_result_type().get_type()) {
9095
      is_static_pls_expr = false;
9096
    }
9097
  }
9098
  return ret;
9099
}
9100

9101
int ObPLResolver::is_static_pls_or_bool_expr(
9102
  const ObRawExpr *expr, bool &static_pls_or_bool_expr)
9103
{
9104
  int ret = OB_SUCCESS;
9105
  CK (OB_NOT_NULL(expr));
9106
  if (OB_FAIL(ret)) {
9107
  } else {
9108
    bool is_static_pls_int_expr = false;
9109
    bool is_static_bool_expr = false;
9110
    OZ (is_static_pls_expr(expr, is_static_pls_int_expr));
9111
    OZ (!is_static_pls_int_expr ? check_static_bool_expr(expr, is_static_bool_expr) : OB_SUCCESS);
9112
    OX (static_pls_or_bool_expr = (is_static_pls_int_expr || is_static_bool_expr));
9113
  }
9114
  return ret;
9115
}
9116

9117
int ObPLResolver::is_static_relation_expr(const ObRawExpr *expr, bool &is_static_relation_expr)
9118
{
9119
  int ret = OB_SUCCESS;
9120
  OX (is_static_relation_expr = false);
9121
  CK (OB_NOT_NULL(expr));
9122
  if (OB_FAIL(ret)) {
9123
  } else if (T_OP_EQ == expr->get_expr_type() // =
9124
             || T_OP_LE == expr->get_expr_type() // <
9125
             || T_OP_LT == expr->get_expr_type() // >
9126
             || T_OP_GE == expr->get_expr_type() // <=
9127
             || T_OP_GT == expr->get_expr_type() // >=
9128
             || T_OP_NE == expr->get_expr_type()) { // <>
9129
    bool static_pls_or_bool_expr = false;
9130
    const ObRawExpr *left = NULL;
9131
    const ObRawExpr *right = NULL;
9132
    CK (2 == expr->get_param_count());
9133
    CK (OB_NOT_NULL(left = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(0))));
9134
    CK (OB_NOT_NULL(right = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(1))));
9135
    OZ (is_static_pls_or_bool_expr(left, static_pls_or_bool_expr));
9136
    OZ (static_pls_or_bool_expr
9137
      ? is_static_pls_or_bool_expr(right, static_pls_or_bool_expr) : OB_SUCCESS);
9138
    OX (is_static_relation_expr = static_pls_or_bool_expr);
9139
  } else if (T_OP_NOT == expr->get_expr_type()) {
9140
    const ObRawExpr *child = NULL;
9141
    CK (1 == expr->get_param_count());
9142
    CK (OB_NOT_NULL(child = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(0))));
9143
    OZ (check_static_bool_expr(child, is_static_relation_expr));
9144
  } else if (T_OP_AND == expr->get_expr_type()
9145
          || T_OP_OR == expr->get_expr_type()) {
9146
    const ObRawExpr *left = NULL;
9147
    const ObRawExpr *right = NULL;
9148
    CK (2 == expr->get_param_count());
9149
    CK (OB_NOT_NULL(left = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(0))));
9150
    CK (OB_NOT_NULL(right = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(1))));
9151
    OZ (check_static_bool_expr(left, is_static_relation_expr));
9152
    OZ (is_static_relation_expr
9153
      ? check_static_bool_expr(right, is_static_relation_expr) : OB_SUCCESS);
9154
  } else if (T_OP_IS == expr->get_expr_type()
9155
            || T_OP_IS_NOT == expr->get_expr_type()) {
9156
    const ObRawExpr *child = NULL;
9157
    const ObConstRawExpr *con_expr = NULL;
9158
    CK (2 == expr->get_param_count());
9159
    CK (OB_NOT_NULL(child = ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(0))));
9160
    CK (OB_NOT_NULL(con_expr = static_cast<const ObConstRawExpr *>
9161
                    (ObRawExprUtils::skip_implicit_cast(expr->get_param_expr(1)))));
9162
    if (OB_SUCC(ret) && ObNullType == con_expr->get_value().get_type()) {
9163
      OZ (is_static_pls_or_bool_expr(child, is_static_relation_expr));
9164
      OZ (!is_static_relation_expr
9165
        ? check_static_bool_expr(child, is_static_relation_expr) : OB_SUCCESS);
9166
    }
9167
  }
9168
  return ret;
9169
}
9170

9171
/*!
9172
 * BOOLEAN Static Expressions BOOLEAN static expressions are:
9173
 *   ■ BOOLEAN literals (TRUE, FALSE, or NULL)
9174
 *   ■ BOOLEAN static constants
9175
 *   ■ Where x and y are PLS_INTEGER static expressions:
9176
 *     – x > y
9177
 *     – x < y
9178
 *     – x >= y
9179
 *     – x <= y
9180
 *     – x = y
9181
 *     – x <> y
9182
 *   ■ Where x and y are BOOLEAN static expressions:
9183
 *     – NOT y
9184
 *     – x AND y
9185
 *     – x OR y
9186
 *     – x > y
9187
 *     - x < y
9188
 *     – x >= y
9189
 *     – x = y
9190
 *     – x <= y
9191
 *     – x <> y
9192
 *   ■ Where x is a static expression:
9193
 *     – x IS NULL
9194
 *     – x IS NOT NULL
9195
 */
9196
int ObPLResolver::check_static_bool_expr(const ObRawExpr *expr, bool &static_bool_expr)
9197
{
9198
  int ret = OB_SUCCESS;
9199
  OX (static_bool_expr = false);
9200
  CK (OB_NOT_NULL(expr));
9201
  if (OB_FAIL(ret)) {
9202
  } else if (OB_FAIL(is_bool_literal_expr(expr, static_bool_expr))) {
9203
    LOG_WARN("failed to call is_bool_literal_expr", K(ret), KPC(expr));
9204
  } else if (!static_bool_expr
9205
    && OB_FAIL(is_static_bool_expr(expr, static_bool_expr))) {
9206
      LOG_WARN("failed to call is_static_bool_expr", K(ret), KPC(expr));
9207
  } else if (!static_bool_expr
9208
    && OB_FAIL(is_static_relation_expr(expr, static_bool_expr))) {
9209
      LOG_WARN("failed to call is_static_relation_expr", K(ret), KPC(expr));
9210
  }
9211
  return ret;
9212
}
9213

9214
// ----------------- check boolean static expr end -------------
9215

9216
int ObPLResolver::resolve_and_calc_static_expr(
9217
  ObPLFunctionAST &unit_ast, const ParseNode &node, ObObjType expect_type, ObObj &result_obj)
9218
{
9219
  int ret = OB_SUCCESS;
9220
  ObRawExpr *expr = NULL;
9221
  OZ (resolve_expr(&node, unit_ast, expr));
9222
  CK (OB_NOT_NULL(expr));
9223
  if (OB_FAIL(ret)) {
9224
  } else if (ObTinyIntType == expect_type) {
9225
    bool is_static_bool_expr = false;
9226
    if (OB_FAIL(check_static_bool_expr(expr, is_static_bool_expr))) {
9227
      LOG_WARN("failed to check static bool expr", K(ret), KPC(expr));
9228
    } else if (!is_static_bool_expr) {
9229
      ret = OB_ERR_STATIC_BOOL_EXPR;
9230
      LOG_WARN("not a bool expr for condition compile", K(ret), KPC(expr));
9231
    }
9232
  } else if (ObVarcharType == expect_type) {
9233
    if (!ob_is_string_tc(expr->get_result_type().get_type())) {
9234
      ret = OB_INVALID_ARGUMENT;
9235
      LOG_WARN("not a varchar expr for condition compile", K(ret), KPC(expr));
9236
    }
9237
  }
9238
  OZ (ObSPIService::spi_calc_raw_expr(
9239
    &(resolve_ctx_.session_info_), &(resolve_ctx_.allocator_), expr, &result_obj));
9240
  return ret;
9241
}
9242

9243
int ObPLResolver::build_raw_expr(const ParseNode &node,
9244
                                 ObRawExpr *&expr,
9245
                                 ObIArray<ObQualifiedName> &columns,
9246
                                 ObIArray<ObVarInfo> &sys_vars,
9247
                                 ObIArray<ObAggFunRawExpr*> &aggr_exprs,
9248
                                 ObIArray<ObWinFunRawExpr*> &win_exprs,
9249
                                 ObIArray<ObSubQueryInfo> &sub_query_info,
9250
                                 ObIArray<ObUDFInfo> &udf_info,
9251
                                 ObIArray<ObOpRawExpr*> &op_exprs,
9252
                                 bool is_prepare_protocol/*= false*/)
9253
{
9254
  int ret = OB_SUCCESS;
9255
  CK(current_block_);
9256
  CK(OB_NOT_NULL(current_block_->get_namespace().get_external_ns()));
9257
  if (OB_SUCC(ret)) {
9258
    const pl::ObPLResolveCtx &ctx = current_block_->get_namespace().get_external_ns()->get_resolve_ctx();
9259
    ObSchemaChecker schema_checker;
9260
    TgTimingEvent tg = static_cast<TgTimingEvent>(resolve_ctx_.params_.tg_timing_event_);
9261
    if (OB_FAIL(schema_checker.init(ctx.schema_guard_,
9262
                                    ctx.session_info_.get_sessid()))) {
9263
      LOG_WARN("failed to init schema checker", K(ret));
9264
    } else if (OB_FAIL(ObRawExprUtils::build_raw_expr(expr_factory_,
9265
                               ctx.session_info_,
9266
                               &schema_checker,
9267
                               &current_block_->get_namespace(),
9268
                               T_PL_SCOPE,
9269
                               NULL/*ObStmt*/,
9270
                               resolve_ctx_.params_.param_list_,
9271
                               NULL/*external_param_info*/,
9272
                               node,
9273
                               expr,
9274
                               columns,
9275
                               sys_vars,
9276
                               aggr_exprs,
9277
                               win_exprs,
9278
                               sub_query_info,
9279
                               udf_info,
9280
                               op_exprs,
9281
                               is_prepare_protocol,
9282
                               tg))) {
9283
      LOG_WARN("failed to build raw expr", K(ret));
9284
    } else { /*do nothing*/ }
9285
  }
9286
  return ret;
9287
}
9288

9289
int ObPLResolver::build_raw_expr(const ParseNode *node,
9290
                                 ObPLCompileUnitAST &unit_ast,
9291
                                 ObRawExpr *&expr,
9292
                                 const ObPLDataType *expected_type)
9293
{
9294
  int ret = OB_SUCCESS;
9295
  ObArray<ObQualifiedName> columns;
9296
  ObArray<ObVarInfo> sys_vars;
9297
  ObArray<ObAggFunRawExpr*> aggr_exprs;
9298
  ObArray<ObWinFunRawExpr*> win_exprs;
9299
  ObArray<ObSubQueryInfo> sub_query_info;
9300
  ObArray<ObUDFInfo> udf_info;
9301
  ObArray<ObOpRawExpr*> op_exprs;
9302
  CK (OB_NOT_NULL(node));
9303
  OZ (build_raw_expr(*node,
9304
                     expr,
9305
                     columns,
9306
                     sys_vars,
9307
                     aggr_exprs,
9308
                     win_exprs,
9309
                     sub_query_info,
9310
                     udf_info,
9311
                     op_exprs,
9312
                     resolve_ctx_.is_prepare_protocol_));
9313
  if (OB_FAIL(ret)) {
9314
    LOG_WARN("build raw expr failed", K(ret));
9315
  } else if (aggr_exprs.count() > 0) {
9316
    ret = OB_NOT_SUPPORTED;
9317
    LOG_WARN("agg expr in pl assign stmt not allowed", K(ret));
9318
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "agg expr in pl assign stmt");
9319
  } else if (sub_query_info.count() > 0) {
9320
    if (lib::is_mysql_mode()) {
9321
      OZ (transform_subquery_expr(node, expr, expected_type, unit_ast));
9322
    } else {
9323
      ret = OB_NOT_SUPPORTED;
9324
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "use subquery in pl/sql expression");
9325
    }
9326
  } else {
9327
    OZ (resolve_columns(expr, columns, unit_ast));
9328
  }
9329
  OV (udf_info.count() <= 0, OB_ERR_UNEXPECTED, K(udf_info));
9330
  if (OB_SUCC(ret) && op_exprs.count() > 0) {
9331
    if (OB_FAIL(ObRawExprUtils::resolve_op_exprs_for_oracle_implicit_cast(expr_factory_,
9332
                                        &resolve_ctx_.session_info_, op_exprs))) {
9333
      LOG_WARN("implicit cast faild", K(ret));
9334
    }
9335
  }
9336

9337
  // record 只能被定义在两个地方，local和package
9338
  if (OB_SUCC(ret) && !OB_ISNULL(expr) &&
9339
      (T_OP_IS == expr->get_expr_type() || T_OP_IS_NOT == expr->get_expr_type())
9340
      && columns.count() > 0) {
9341
    uint64_t parent_id = OB_INVALID_INDEX;
9342
    int64_t var_index = OB_INVALID_INDEX;
9343
    ObPLExternalNS::ExternalType type = ObPLExternalNS::INVALID_VAR;
9344
    ObPLDataType pl_data_type;
9345
    int64_t ident_cnt = columns.at(0).access_idents_.count();
9346
    ObPLBlockNS &ns = current_block_->get_namespace();
9347
    int64_t tmp_ret = OB_SUCCESS;
9348
    if (1 < ident_cnt) {
9349
        // try record type inside package
9350
        type = ObPLExternalNS::PKG_NS;
9351
        const ObString &pkg_name = columns.at(0).access_idents_.at(0).access_name_;
9352
        if (OB_SUCCESS != (tmp_ret =resolve_ctx_.session_info_.get_database_id(parent_id))) {
9353
          LOG_WARN("get database id failed.", K(tmp_ret));
9354
        } else if (OB_SUCCESS != (tmp_ret = ns.resolve_symbol(pkg_name,
9355
                                                                  type,
9356
                                                                  pl_data_type,
9357
                                                                  parent_id,
9358
                                                                  var_index))) {
9359
          LOG_WARN("failed to get var index", K(pl_data_type), K(tmp_ret));
9360
        } else {
9361
          parent_id = var_index;
9362
          type = ObPLExternalNS::PKG_VAR;
9363
          var_index = OB_INVALID_INDEX;
9364
        }
9365
    } else {
9366
      // do nothing
9367
    }
9368
    if (OB_SUCCESS == tmp_ret && !columns.at(0).col_name_.empty()) {
9369
    // we don't want the ret code to be cover intendedly
9370
      if (OB_SUCCESS != (tmp_ret = ns.resolve_symbol(columns.at(0).col_name_,
9371
                                          type,
9372
                                          pl_data_type,
9373
                                          parent_id,
9374
                                          var_index))) {
9375
        LOG_WARN("failed to get var index", K(pl_data_type), K(ret));
9376
      } else {
9377
        if (pl_data_type.is_record_type() && !pl_data_type.is_object_type()) {
9378
          ret = OB_NOT_SUPPORTED;
9379
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "record type nullable test");
9380
          LOG_WARN("record type is not allowed for nullable test.",
9381
                   K(ret),
9382
                   K(columns.at(0).col_name_),
9383
                   K(parent_id),
9384
                   K(var_index),
9385
                   K(pl_data_type));
9386
        }
9387
      }
9388
    }
9389
  }
9390
  OZ (ObRawExprUtils::set_call_in_pl(expr));
9391
  return ret;
9392
}
9393

9394
bool ObPLResolver::is_json_type_compatible(const ObUserDefinedType *left, const ObUserDefinedType *right)
9395
{
9396
#ifdef OB_BUILD_ORACLE_PL
9397
  return (ObPlJsonUtil::is_pl_json_element_type(left->get_user_type_id())
9398
          && ObPlJsonUtil::is_pl_json_object_type(right->get_user_type_id())) ;
9399
#else
9400
  return false;
9401
#endif
9402
}
9403

9404
int ObPLResolver::check_composite_compatible(const ObPLINS &ns,
9405
                                             uint64_t left_type_id,
9406
                                             uint64_t right_type_id,
9407
                                             bool &is_compatible)
9408
{
9409
  int ret = OB_SUCCESS;
9410
  const ObUserDefinedType *left_type = NULL;
9411
  const ObUserDefinedType *right_type = NULL;
9412
  ObArenaAllocator allocator;
9413
  is_compatible = false;
9414
  //NOTICE: do not call this function when left_type_id equal to right_type_id
9415
  CK (left_type_id != right_type_id);
9416
  OZ (ns.get_user_type(left_type_id, left_type, &allocator));
9417
  OZ (ns.get_user_type(right_type_id, right_type, &allocator));
9418
  CK (OB_NOT_NULL(left_type) && OB_NOT_NULL(right_type));
9419
  // Assigning One Record Variable to Another
9420
  // You can assign the value of one record variable to another record variable only in these cases:
9421
  // The two variables have the same RECORD type.
9422
  // The target variable is declared with a RECORD type, the source variable is declared with %ROWTYPE,
9423
  // their fields match in number and order, and corresponding fields have the same data type.
9424
  // For record components of composite variables, the types of the composite variables need not match.
9425
  if (OB_FAIL(ret)) {
9426
  } else if (is_json_type_compatible(left_type, right_type)) {
9427
    is_compatible = true;
9428
  } else if (left_type->is_cursor_type() && right_type->is_cursor_type()) {
9429
    is_compatible = true;
9430
  } else if (right_type->is_generic_type()) {
9431
    if ((right_type->is_generic_adt_type()
9432
         || right_type->is_generic_record_type())
9433
        && left_type->is_record_type()) {
9434
      is_compatible = true;
9435
    } else if ((right_type->is_generic_varray_type()
9436
               || right_type->is_generic_v2_table_type()
9437
               || right_type->is_generic_table_type()
9438
               || right_type->is_generic_collection_type())
9439
              && left_type->is_collection_type()) {
9440
      is_compatible = true;
9441
    } else if (right_type->is_generic_ref_cursor_type()
9442
               && left_type->is_cursor_type()) {
9443
      is_compatible = true;
9444
    }
9445
  } else if (left_type->is_record_type()
9446
      && right_type->is_record_type()
9447
      && !left_type->is_udt_type()
9448
      && !right_type->is_udt_type()
9449
      && (left_type->is_rowtype_type() || right_type->is_rowtype_type())) {
9450
    const ObRecordType *left_r_type = static_cast<const ObRecordType *>(left_type);
9451
    const ObRecordType *right_r_type = static_cast<const ObRecordType *>(right_type);
9452
    CK (OB_NOT_NULL(left_r_type) && OB_NOT_NULL(right_r_type));
9453
    OZ (left_r_type->is_compatble(*right_r_type, is_compatible));
9454
  }
9455
  return ret;
9456
}
9457

9458
int ObPLResolver::check_collection_expr_illegal(const ObRawExpr *expr, bool &is_obj_acc)
9459
{
9460
  int ret = OB_SUCCESS;
9461
  if (OB_ISNULL(expr)) {
9462
    ret = OB_ERR_UNEXPECTED;
9463
    LOG_WARN("expr is null", K(ret));
9464
  } else {
9465
    is_obj_acc = false;
9466
    const ObOpRawExpr *op_cmp = static_cast<const ObOpRawExpr *>(expr);
9467
    const ObRawExpr *left = op_cmp->get_param_expr(0);
9468
    const ObRawExpr *right = op_cmp->get_param_expr(1);
9469
    // record and collection must be obj access
9470
    if (OB_ISNULL(left) || OB_ISNULL(right)) {
9471
      ret = OB_ERR_UNEXPECTED;
9472
      LOG_WARN("expr left or right children is null", K(ret));
9473
    } else {
9474
      if (T_OBJ_ACCESS_REF == left->get_expr_type()
9475
          && T_OBJ_ACCESS_REF == right->get_expr_type()) {
9476
        const ObObjAccessRawExpr *l = static_cast<const ObObjAccessRawExpr *>(left);
9477
        const ObObjAccessRawExpr *r = static_cast<const ObObjAccessRawExpr *>(right);
9478
        is_obj_acc = true;
9479
        if ((ObObjAccessIdx::get_final_type(l->get_access_idxs()).is_varray_type()
9480
            || ObObjAccessIdx::get_final_type(r->get_access_idxs()).is_varray_type())
9481
            || (ObObjAccessIdx::get_final_type(l->get_access_idxs()).is_associative_array_type()
9482
            || ObObjAccessIdx::get_final_type(r->get_access_idxs()).is_associative_array_type())) {
9483
          ret = OB_NOT_SUPPORTED;
9484
          LOG_WARN("not supported varray or associative array compared.", K(ret));
9485
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "varray or associative array compared");
9486
        }
9487
      }
9488
    }
9489
  }
9490
  return ret;
9491
}
9492

9493
int ObPLResolver::formalize_expr(ObRawExpr &expr)
9494
{
9495
  int ret = OB_SUCCESS;
9496
  stmt::StmtType stmt_type_bak = resolve_ctx_.session_info_.get_stmt_type();
9497
  resolve_ctx_.session_info_.set_stmt_type(stmt::T_NONE);
9498
  OZ (expr.formalize(&resolve_ctx_.session_info_));
9499
  OZ (formalize_expr(expr, &resolve_ctx_.session_info_, current_block_->get_namespace()));
9500
  resolve_ctx_.session_info_.set_stmt_type(stmt_type_bak);
9501
  return ret;
9502
}
9503

9504
int ObPLResolver::formalize_expr(ObRawExpr &expr,
9505
                                 const ObSQLSessionInfo *session_info,
9506
                                 const ObPLINS &ns)
9507
{
9508
  int ret = OB_SUCCESS;
9509
  if (OB_SUCC(ret)
9510
      && expr.get_result_type().is_ext()
9511
      && OB_INVALID_ID != expr.get_udt_id()) {
9512
    int64_t size = 0;
9513
    const ObUserDefinedType *user_type = NULL;
9514
    OZ (ns.get_user_type(expr.get_udt_id(), user_type, NULL));
9515
    CK (OB_NOT_NULL(user_type));
9516
    OZ (user_type->get_size(ns, PL_TYPE_INIT_SIZE, size));
9517
    OX (const_cast<ObExprResType&>(expr.get_result_type()).set_extend_size(size));
9518
  }
9519
  for (int64_t i = 0; OB_SUCC(ret) && i < expr.get_param_count(); ++i) {
9520
    ObRawExpr *child_expr = expr.get_param_expr(i);
9521
    if (OB_NOT_NULL(child_expr)) {
9522
      OZ (formalize_expr(*child_expr, session_info, ns));
9523
      if (OB_SUCC(ret) && expr.is_udf_expr()) {
9524
        ObUDFRawExpr &udf_expr = static_cast<ObUDFRawExpr&>(expr);
9525
        ObIArray<ObExprResType>& params_type = udf_expr.get_params_type();
9526
        if (params_type.at(i).is_ext()) {
9527
          params_type.at(i).set_udt_id(child_expr->get_udt_id());
9528
        }
9529
      }
9530
    }
9531
  }
9532
  return ret;
9533
}
9534

9535
int ObPLResolver::set_cm_warn_on_fail(ObRawExpr *&expr)
9536
{
9537
  int ret = OB_SUCCESS;
9538
  CK (OB_NOT_NULL(expr));
9539
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
9540
    OZ (set_cm_warn_on_fail(expr->get_param_expr(i)));
9541
  }
9542
  if (OB_SUCC(ret)) {
9543
    if (T_FUN_SYS_CAST == expr->get_expr_type()) {
9544
      expr->set_extra(expr->get_extra() | CM_WARN_ON_FAIL);
9545
    } else if (T_FUN_SUBQUERY == expr->get_expr_type()) {
9546
      ObPlQueryRefRawExpr *subquery_expr = static_cast<ObPlQueryRefRawExpr *>(expr);
9547
      subquery_expr->set_ignore_fail();
9548
    }
9549
  }
9550
  return ret;
9551
}
9552

9553
int ObPLResolver::analyze_expr_type(ObRawExpr *&expr,
9554
                                    ObPLCompileUnitAST &unit_ast)
9555
{
9556
  int ret = OB_SUCCESS;
9557
  CK (OB_NOT_NULL(expr));
9558
  if (OB_FAIL(ret)) {
9559
  } else if (T_OP_GET_PACKAGE_VAR == expr->get_expr_type()) {
9560
    OX (unit_ast.set_rps());
9561
  } else if (T_FUN_UDF == expr->get_expr_type() ||
9562
             T_OP_GET_SYS_VAR == expr->get_expr_type() ||
9563
             T_OP_GET_USER_VAR == expr->get_expr_type() ||
9564
             (T_FUN_SUBQUERY == expr->get_expr_type() && lib::is_mysql_mode())) { // user var expr has been rewrite to subquery expr in mysql mode
9565
    OX (unit_ast.set_external_state());
9566
  } else {
9567
    for (int64_t i = 0;
9568
         OB_SUCC(ret) &&
9569
         (!unit_ast.is_rps() || !unit_ast.is_external_state()) &&
9570
         i < expr->get_param_count();
9571
         ++i) {
9572
      OZ (analyze_expr_type(expr->get_param_expr(i), unit_ast));
9573
    }
9574
  }
9575
  return ret;
9576
}
9577

9578
int ObPLResolver::resolve_expr(const ParseNode *node,
9579
                               ObPLCompileUnitAST &unit_ast,
9580
                               ObRawExpr *&expr,
9581
                               uint64_t line_number,
9582
                               bool need_add,
9583
                               const ObPLDataType *expected_type,
9584
                               bool is_behind_limit,
9585
                               bool is_add_bool)
9586
{
9587
  int ret = OB_SUCCESS;
9588
  // Step 1: resolve parse node to raw expr
9589
  OZ (build_raw_expr(node, unit_ast, expr, expected_type));
9590
  CK (OB_NOT_NULL(expr));
9591
  OZ (replace_object_compare_expr(expr, unit_ast));
9592
  OZ (analyze_expr_type(expr, unit_ast));
9593
  // check op illegal
9594
  if (OB_SUCC(ret) && OB_NOT_NULL(expr)
9595
      && (T_OP_EQ == expr->get_expr_type() || T_OP_NE == expr->get_expr_type())) {
9596
    bool is_obj_acc = false;
9597
    OZ (check_collection_expr_illegal(expr, is_obj_acc));
9598
  }
9599

9600
  CK (OB_NOT_NULL(current_block_));
9601
#ifdef OB_BUILD_ORACLE_PL
9602
  OZ (current_block_->get_namespace().get_subtype_actually_basetype(expected_type, expected_type));
9603
#endif
9604

9605
  // check op illegal
9606
  if (OB_SUCC(ret) && !OB_ISNULL(expr) && (T_OP_MULTISET == expr->get_expr_type())) {
9607
    bool is_obj_acc = false;
9608
    if (OB_FAIL(check_collection_expr_illegal(expr, is_obj_acc))) {
9609
      LOG_WARN("failed to check collection expr illegal", K(ret));
9610
    } else if (!is_obj_acc) {
9611
      ret = OB_NOT_SUPPORTED;
9612
      LOG_WARN("multiset op should apply to nested tables", K(ret));
9613
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "multiset op is applied to non-nested tables");
9614
    } else {
9615
      // do nothing
9616
    }
9617
  }
9618

9619
  // Step 2: process call param raw expr
9620
  ObCallParamRawExpr *call_expr = NULL;
9621
  if (OB_SUCC(ret) && T_SP_CPARAM == expr->get_expr_type()) {
9622
    CK (OB_NOT_NULL(call_expr = static_cast<ObCallParamRawExpr*>(expr)));
9623
    CK (OB_NOT_NULL(expr = call_expr->get_expr()));
9624
  }
9625

9626
  // Step 3: add pls integer checker
9627
  OZ (formalize_expr(*expr));
9628
  bool need_replace = false;
9629
  if (OB_SUCC(ret) && lib::is_oracle_mode()) {
9630
    OZ (add_pl_integer_checker_expr(expr_factory_, expr, need_replace));
9631
  }
9632
  if (OB_SUCC(ret) && expr->is_udf_expr()) {
9633
    ObUDFRawExpr *udf_expr = static_cast<ObUDFRawExpr *>(expr);
9634
    udf_expr->set_loc(line_number);
9635
  }
9636
  if (is_mysql_mode()) {
9637
    ObRawExprWrapEnumSet enum_set_wrapper(expr_factory_, &resolve_ctx_.session_info_);
9638
    OZ (enum_set_wrapper.analyze_expr(expr));
9639
  }
9640
  OZ (formalize_expr(*expr));
9641

9642
  // Step 4: check complex cast legal
9643
  // 原来是step2，移动这里是因为result type需要deduce一把才能出来结果。
9644
  // 放在step是有问题，因为类似T_SP_CPARAM是没有对应的expr执行实体，需要展开. 没展开deduce就会出问题。
9645
  bool pl_sql_format_convert = false;
9646
  if (OB_SUCC(ret) && OB_NOT_NULL(expected_type)) {
9647
    if (T_OP_ROW == expr->get_expr_type()) {
9648
      ret = OB_ERR_EXPRESSION_WRONG_TYPE;
9649
      LOG_WARN("PLS-00382: expression is of wrong type",
9650
               K(ret), K(expected_type->is_obj_type()), KPC(expr));
9651
    } else if (ObNullType == expr->get_result_type().get_obj_meta().get_type()) {
9652
      // do nothing
9653
    } else if (expected_type->is_opaque_type()
9654
               && expected_type->get_user_type_id() == static_cast<uint64_t>(T_OBJ_XML)
9655
               && expr->get_result_type().is_xml_sql_type()) {
9656
      pl_sql_format_convert = true;
9657
    } else if ((!expected_type->is_obj_type()
9658
                 && expr->get_result_type().get_obj_meta().get_type() != ObExtendType)
9659
               || (expected_type->is_obj_type()
9660
                   && expr->get_result_type().get_obj_meta().get_type() == ObExtendType)) {
9661
      ret = OB_ERR_EXPRESSION_WRONG_TYPE;
9662
      LOG_WARN("PLS-00382: expression is of wrong type",
9663
               K(ret), K(expected_type->is_obj_type()), K(expr->get_result_type().get_obj_meta().get_type()));
9664
    } else if (expected_type->is_composite_type()
9665
               && expr->get_result_type().get_obj_meta().is_ext()
9666
               && expected_type->get_user_type_id() != expr->get_result_type().get_udt_id()
9667
               && expr->get_expr_type() != T_FUN_SYS_PDB_GET_RUNTIME_INFO) {
9668
      bool is_compatible = false;
9669
      OZ (check_composite_compatible(current_block_->get_namespace(),
9670
                                     expected_type->get_user_type_id(),
9671
                                     expr->get_result_type().get_udt_id(),
9672
                                     is_compatible));
9673
      if (OB_FAIL(ret)) {
9674
      } else if (!is_compatible) {
9675
        ret = OB_ERR_INVALID_TYPE_FOR_OP;
9676
#ifdef OB_BUILD_ORACLE_PL
9677
        // error code compiltable with oracle
9678
        if (ObPlJsonUtil::is_pl_json_object_type(expected_type->get_user_type_id())
9679
            && ObPlJsonUtil::is_pl_json_element_type(expr->get_result_type().get_udt_id())) {
9680
          ret = OB_ERR_EXPRESSION_WRONG_TYPE;
9681
        }
9682
#endif
9683
        LOG_WARN("PLS-00382: expression is of wrong type",
9684
                  K(ret), K(expected_type->is_obj_type()), KPC(expr),
9685
                  K(expr->get_result_type().get_obj_meta().get_type()),
9686
                  K(expected_type->get_user_type_id()),
9687
                  K(expr->get_result_type().get_udt_id()));
9688
      }
9689
    }
9690
  }
9691

9692
  // Step 5: check can simple pls integer opt
9693
  bool simple_pls_integer = false;
9694
  if (OB_SUCC(ret)
9695
      && lib::is_oracle_mode()
9696
      && OB_NOT_NULL(expected_type)
9697
      && expected_type->is_pl_integer_type()
9698
      && expected_type->is_default_pls_range()
9699
      && expr->is_const_raw_expr()) {
9700
    //Int类型的Const向PLS_INTEGER赋值，可忽略pl_integer_checker和column_conv
9701
    if (static_cast<ObConstRawExpr*>(expr)->get_value().is_integer_type()
9702
        && static_cast<ObConstRawExpr*>(expr)->get_value().get_int() >= INT32_MIN
9703
        && static_cast<ObConstRawExpr*>(expr)->get_value().get_int() <= INT32_MAX) {
9704
      static_cast<ObConstRawExpr*>(expr)->get_value().set_type(ObInt32Type);
9705
      static_cast<ObConstRawExpr*>(expr)->
9706
                   set_expr_obj_meta(static_cast<ObConstRawExpr*>(expr)->get_value().get_meta());
9707
      expr->set_data_type(ObInt32Type);
9708
      simple_pls_integer = true;
9709
    } else if (static_cast<ObConstRawExpr*>(expr)->get_value().is_number()) {
9710
      int64_t int_value = 0;
9711
      if (static_cast<ObConstRawExpr*>(expr)->get_value().get_number().is_valid_int64(int_value)
9712
          && int_value >= INT32_MIN
9713
          && int_value <= INT32_MAX) {
9714
        static_cast<ObConstRawExpr*>(expr)->get_value().set_int32(static_cast<int32_t>(int_value));
9715
        static_cast<ObConstRawExpr*>(expr)->set_expr_obj_meta(
9716
                                        static_cast<ObConstRawExpr*>(expr)->get_value().get_meta());
9717
        expr->set_data_type(ObInt32Type);
9718
        simple_pls_integer = true;
9719
      }
9720
    } else { /*do nothing*/ }
9721
  } else { /*do nothing*/ }
9722

9723
  // Step 6: check need to cast
9724
  bool need_cast = false;
9725
  const ObDataType *data_type =
9726
    OB_NOT_NULL(expected_type) ? expected_type->get_data_type() : NULL;
9727
  if (OB_SUCC(ret) && !simple_pls_integer && OB_NOT_NULL(data_type) && !pl_sql_format_convert) {
9728
    need_cast = (ob_is_enum_or_set_type(data_type->get_obj_type())
9729
                || expr->get_result_type().get_obj_meta() != data_type->get_meta_type()
9730
                || expr->get_result_type().get_accuracy() != data_type->get_accuracy());
9731
    need_cast = need_cast
9732
      || (expr->get_result_type().get_obj_meta() == data_type->get_meta_type()
9733
          && data_type->get_meta_type().is_integer_type());
9734
  }
9735

9736
  // check boolean expr legal
9737
  if (OB_SUCC(ret) && need_cast && lib::is_oracle_mode()) {
9738
    // expected expr is boolean expr
9739
    if (data_type->get_obj_type() == ObTinyIntType) {
9740
      if (IS_BOOL_OP(expr->get_expr_type())
9741
          || T_NULL == expr->get_expr_type()
9742
          || ObTinyIntType == expr->get_result_type().get_type()) {
9743
        // do nothing ...
9744
      } else if (T_QUESTIONMARK == expr->get_expr_type() &&
9745
                 ObNullType == expr->get_data_type()) {
9746
        // do nothing ...
9747
      } else {
9748
        ret = OB_ERR_INVALID_TYPE_FOR_OP;
9749
        LOG_WARN("PLS-00382: expression is of wrong type",
9750
                  K(ret), KPC(data_type), KPC(expr));
9751
      }
9752
    } else if ((IS_BOOL_OP(expr->get_expr_type()) || ObTinyIntType == expr->get_result_type().get_type())
9753
               && ObTinyIntType != data_type->get_obj_type()) {
9754
      ret = OB_ERR_EXPRESSION_WRONG_TYPE;
9755
      LOG_WARN("PLS-00382: expression is of wrong type", K(ret), KPC(data_type), KPC(expr));
9756
    }
9757
  }
9758

9759
  // check limit for oracle
9760
  if (OB_SUCC(ret) && is_behind_limit && lib::is_oracle_mode()) {
9761
    ObObjMeta limit_meta = expr->get_result_type();
9762
    if (limit_meta.is_numeric_type()) {
9763
      //do nothing
9764
    } else if (limit_meta.is_character_type()) {
9765
      ret = OB_ERR_LIMIT_CLAUSE;
9766
      LOG_WARN("value in LIMIT clause is invalid", K(ret), KPC(data_type), KPC(expr));
9767
    } else {
9768
      ret = OB_ERR_EXPRESSION_WRONG_TYPE;
9769
      LOG_WARN("expression is of wrong type", K(ret), KPC(data_type), KPC(expr));
9770
    }
9771
  }
9772

9773
  // Step 7: do actually cast
9774
  if (OB_FAIL(ret)) {
9775
  } else if (is_add_bool) {
9776
    ObOpRawExpr *bool_expr = NULL;
9777
    if (OB_FAIL(expr_factory_.create_raw_expr(T_OP_BOOL, bool_expr))) {
9778
      LOG_WARN("create bool expr failed", K(ret));
9779
    } else if (OB_ISNULL(bool_expr)) {
9780
      ret = OB_ERR_UNEXPECTED;
9781
      LOG_WARN("bool_expr is NULL", K(ret));
9782
    } else {
9783
      OZ(bool_expr->add_flag(IS_INNER_ADDED_EXPR));
9784
      OZ(bool_expr->add_param_expr(expr));
9785
      OX(expr = bool_expr);
9786
      OZ (formalize_expr(*expr));
9787
      OZ (set_cm_warn_on_fail(expr));
9788
    }
9789
  } else if (need_cast) {
9790
    bool need_wrap = false;
9791
    OZ (ObRawExprUtils::need_wrap_to_string(expr->get_result_type().get_type(),
9792
                                            data_type->get_obj_type(),
9793
                                            true,
9794
                                            need_wrap));
9795
    if (OB_SUCC(ret) && need_wrap) {
9796
      ObSysFunRawExpr *out_expr = NULL;
9797
      OZ (ObRawExprUtils::create_type_to_str_expr(expr_factory_,
9798
                                                  expr,
9799
                                                  out_expr,
9800
                                                  &resolve_ctx_.session_info_,
9801
                                                  true));
9802
      CK (OB_NOT_NULL(out_expr));
9803
      OX (expr = out_expr);
9804
    }
9805
    OZ (ObRawExprUtils::build_column_conv_expr(&resolve_ctx_.session_info_,
9806
                                               expr_factory_,
9807
                                               data_type->get_obj_type(),
9808
                                               data_type->get_collation_type(),
9809
                                               data_type->get_accuracy_value(),
9810
                                               true,
9811
                                               NULL, /*"db_name"."tb_name"."col_name"*/
9812
                                               &expected_type->get_type_info(),
9813
                                               expr,
9814
                                               true /*is_in_pl*/));
9815
  }
9816

9817
  // Step 8: add pls integer checker again
9818
  if (OB_SUCC(ret)
9819
     && !simple_pls_integer
9820
     && OB_NOT_NULL(expected_type)
9821
     && expected_type->is_pl_integer_type()
9822
     && is_need_add_checker(expected_type->get_pl_integer_type(), expr)) {
9823
    OZ (add_pl_integer_checker_expr(expr_factory_,
9824
                                    PL_SIMPLE_INTEGER == expected_type->get_pl_integer_type()
9825
                                      ? PL_PLS_INTEGER : expected_type->get_pl_integer_type(),
9826
                                    expected_type->get_lower(),
9827
                                    expected_type->get_upper(),
9828
                                    expr));
9829
    OZ (formalize_expr(*expr));
9830
  }
9831

9832
  // Step 9: const folding opt.
9833
  if (OB_SUCC(ret) && OB_FAIL(replace_to_const_expr_if_need(expr))) {
9834
    // 兼容MySQL,Oralce, 计算过程中如果出错不在此阶段报, 执行阶段报
9835
    ret = OB_SUCCESS;
9836
  }
9837

9838
  //in static typing engine, we wont do implict cast at stage of execution,
9839
  //for some expr like ObExprIn/ObExprArgCase, if type of left is not match with right,
9840
  //we rewrite "a in (b,c)" to "a in b or a in c"
9841
  //"case a when b xx when c xx" to "case when a == b then xx case when a == c then xx"
9842
  if (OB_SUCC(ret)) {
9843
    bool transformed = false;
9844
    OZ(ObTransformPreProcess::transform_expr(unit_ast.get_expr_factory(),
9845
                                              resolve_ctx_.session_info_, expr,
9846
                                              transformed));
9847
  }
9848

9849

9850
  // Step 10: add expr to ast if needed
9851
  OZ (need_add ? unit_ast.add_expr(expr, simple_pls_integer) : OB_SUCCESS);
9852
  // When raw expr calls formalize for type deduce in the new engine, if the src type is
9853
  // inconsistent with the dst type, an implicit cast will be added to ensure that the new engine
9854
  // does not make a mistake in cg. but add_expr calls check_simple_calc_expr to rewrite the
9855
  // type in some special cases, and this may happen after formalize.
9856
  // Therefore, we need to call formalize again after add expr to ensure
9857
  // that the types are inconsistent with an implicit cast
9858
  if (OB_SUCC(ret)) {
9859
    OZ (formalize_expr(*expr));
9860
  }
9861

9862
  // Step 11: process call param raw expr
9863
  if (OB_SUCC(ret) && OB_NOT_NULL(call_expr)) {
9864
    call_expr->set_expr(expr);
9865
    expr = call_expr;
9866
  }
9867
  OZ (ObRawExprUtils::set_call_in_pl(expr));
9868
  if (OB_FAIL(ret)) {
9869
    record_error_line(node, resolve_ctx_.session_info_);
9870
  }
9871
  return ret;
9872
}
9873

9874

9875
int ObPLResolver::transform_subquery_expr(const ParseNode *node,
9876
                                          ObRawExpr *&expr,
9877
                                          const ObPLDataType *expected_type,
9878
                                          ObPLCompileUnitAST &func)
9879
{
9880
  int ret = OB_SUCCESS;
9881
  CK (OB_NOT_NULL(expr));
9882

9883
  if (OB_SUCC(ret)) {
9884
    pl::ObRecordType *record_type = nullptr;
9885
    if (OB_ISNULL(record_type =
9886
              static_cast<ObRecordType*>(resolve_ctx_.allocator_.alloc(sizeof(ObRecordType))))) {
9887
      ret = OB_ALLOCATE_MEMORY_FAILED;
9888
      LOG_WARN("failed to alloc memory", K(ret));
9889
    } else {
9890
      record_type = new(record_type)ObRecordType();
9891
      record_type->set_type_from(PL_TYPE_ATTR_ROWTYPE);
9892
    }
9893

9894
    sql::ObSPIService::ObSPIPrepareResult prepare_result;
9895

9896
    prepare_result.record_type_ = record_type;
9897
    prepare_result.tg_timing_event_ =
9898
                        static_cast<TgTimingEvent>(resolve_ctx_.params_.tg_timing_event_);
9899
    question_mark_cnt_ = node->value_;
9900
    int64_t total_size = 7 + node->str_len_ + strlen(" as 'subquery'") + 1;
9901
    char *sql_str = static_cast<char *>(resolve_ctx_.allocator_.alloc(total_size));
9902
    int64_t sql_len = 0;
9903
    MEMMOVE(sql_str, "SELECT ", 7);
9904
    sql_len += 7;
9905
    MEMMOVE(sql_str + sql_len, node->str_value_, node->str_len_);
9906
    sql_len += node->str_len_;
9907
    MEMMOVE(sql_str + sql_len, " as 'subquery'", strlen(" as 'subquery'"));
9908
    sql_len += strlen(" as 'subquery'");
9909
    sql_str[sql_len] = '\0';
9910

9911
    if (OB_FAIL(ret)) {
9912
    } else if (OB_FAIL(ObSPIService::spi_prepare(resolve_ctx_.allocator_,
9913
                              resolve_ctx_.session_info_,
9914
                              resolve_ctx_.sql_proxy_,
9915
                              resolve_ctx_.schema_guard_,
9916
                              expr_factory_,
9917
                              sql_str,
9918
                              false,
9919
                              &current_block_->get_namespace(),
9920
                              prepare_result))) {
9921
      LOG_WARN("failed to prepare stmt", K(ret));
9922
    } else if (0 != prepare_result.into_exprs_.count()) {
9923
      ret = OB_ERR_UNEXPECTED;
9924
      LOG_WARN("unexpected into expr", K(ret));
9925
    } else if (OB_FAIL(func.add_sql_exprs(prepare_result.exec_params_))) {
9926
      LOG_WARN("failed to set precalc exprs", K(prepare_result.exec_params_), K(ret));
9927
    } else if (OB_FAIL(func.add_dependency_objects(prepare_result.ref_objects_))) {
9928
      LOG_WARN("failed to add dependency objects", K(prepare_result.ref_objects_), K(ret));
9929
    } else {
9930
      if (!func.is_modifies_sql_data()) {
9931
        func.set_reads_sql_data();
9932
      }
9933
    }
9934

9935
    if (OB_SUCC(ret)) {
9936
      ObPlQueryRefRawExpr *subquery_expr = nullptr;
9937
      OZ (expr_factory_.create_raw_expr(T_FUN_SUBQUERY, subquery_expr));
9938

9939
      OX (subquery_expr->set_ps_sql(prepare_result.ps_sql_));
9940
      OX (subquery_expr->set_stmt_type(prepare_result.type_));
9941
      OX (subquery_expr->set_route_sql(prepare_result.route_sql_));
9942

9943
      for (int64_t i = 0; OB_SUCC(ret) && i < prepare_result.exec_params_.count(); ++i) {
9944
        OZ (subquery_expr->add_param_expr(prepare_result.exec_params_.at(i)));
9945
      }
9946

9947
      ObExprResType result_type;
9948
      // todo: subquery expression result type need optimizate in mysql mode
9949
      ObPLDataType data_type(ObVarcharType);
9950
      const ObDataType *subquery_data_type = nullptr;
9951
      if (OB_SUCC(ret)) {
9952
        if (nullptr == expected_type || nullptr == expected_type->get_meta_type() ||
9953
            nullptr == expected_type->get_data_type()) {
9954
          expected_type = &data_type;
9955
        }
9956
        subquery_data_type = expected_type->get_data_type();
9957

9958
        OX (result_type.set_accuracy(subquery_data_type->get_accuracy()));
9959
        OX (result_type.set_type(subquery_data_type->get_obj_type()));
9960
        OX (result_type.set_meta(subquery_data_type->get_meta_type()));
9961
        OX (result_type.set_length(subquery_data_type->get_length()));
9962

9963
        ObCollationType collation_type = result_type.get_collation_type();
9964
        if (OB_SUCC(ret) && CS_TYPE_INVALID == collation_type) {
9965
          OZ (resolve_ctx_.session_info_.get_collation_connection(collation_type));
9966

9967
          OX (result_type.set_collation_type(collation_type));
9968
          OX (result_type.set_collation_level(CS_LEVEL_IMPLICIT));
9969
        }
9970

9971
        OX (subquery_expr->set_subquery_result_type(result_type));
9972
        OX (expr = subquery_expr);
9973
      } else {
9974
        ret = OB_ERR_UNEXPECTED;
9975
        LOG_WARN("inner error", K(ret));
9976
      }
9977
    }
9978
  }
9979
  return ret;
9980
}
9981

9982
int ObPLResolver::try_transform_assign_to_dynamic_SQL(ObPLStmt *&old_stmt, ObPLFunctionAST &func)
9983
{
9984
  int ret = OB_SUCCESS;
9985
  int64_t into_count = OB_INVALID_COUNT;
9986
  int64_t value_count = OB_INVALID_COUNT;
9987
  int64_t expr_count = OB_INVALID_COUNT;
9988
  ObPLAssignStmt * assign_stmt = NULL;
9989
  CK (OB_NOT_NULL(assign_stmt = static_cast<ObPLAssignStmt *>(old_stmt)));
9990
  OX (into_count = assign_stmt->get_into_count());
9991
  OX (value_count = assign_stmt->get_value_count());
9992
  if(lib::is_mysql_mode() && into_count > 0 && value_count > 0 && into_count == value_count) {
9993
    bool is_need_transform_to_dynamic = false;
9994
    ObSEArray<int64_t, 1> var_val_pos_array;
9995
    OX (expr_count = func.get_expr_count());
9996
    for(int64_t i = 0; i < into_count && OB_SUCC(ret); i++) {
9997
      ObRawExpr* sql_expr = NULL;
9998
      ObRawExpr* into_expr = NULL;
9999
      int64_t sql_expr_index = assign_stmt->get_value_index(i);
10000
      int64_t into_expr_index = assign_stmt->get_into_index(i);
10001
      CK (sql_expr_index >= 0 && sql_expr_index < expr_count && into_expr_index >= 0 && into_expr_index < expr_count);
10002
      CK (OB_NOT_NULL(sql_expr = func.get_expr(sql_expr_index)));
10003
      CK (OB_NOT_NULL(into_expr = func.get_expr(into_expr_index)));
10004
      if(OB_SUCC(ret) && sql_expr->get_expr_type() == T_FUN_SUBQUERY &&
10005
        into_expr->get_expr_type() == T_OP_GET_USER_VAR) {
10006
          OZ (transform_to_new_assign_stmt(var_val_pos_array, assign_stmt));
10007
          OZ (transform_var_val_to_dynamic_SQL(sql_expr_index, into_expr_index, func));
10008
          OX (is_need_transform_to_dynamic = true);
10009
          LOG_INFO("try transform var_val to dynamic SQL!",K(ret), K(sql_expr_index), K(into_expr_index), K(i));
10010
      } else {
10011
        OZ (var_val_pos_array.push_back(i));
10012
      }
10013
    }
10014
    if(OB_SUCC(ret) && is_need_transform_to_dynamic) {
10015
      if(!var_val_pos_array.empty()) {
10016
        OZ (transform_to_new_assign_stmt(var_val_pos_array, assign_stmt));
10017
      }
10018
      old_stmt->~ObPLStmt();
10019
      OX (old_stmt = NULL);
10020
    }
10021
  }
10022
  return ret;
10023
}
10024

10025
int ObPLResolver::transform_var_val_to_dynamic_SQL(int64_t sql_expr_index, int64_t into_expr_index, ObPLFunctionAST &func)
10026
{
10027
  int ret = OB_SUCCESS;
10028
  ObPLStmt *stmt = NULL;
10029
  ObPLExecuteStmt* execute_stmt = NULL;
10030
  ObObjParam val;
10031
  ObString str_val;
10032
  ObConstRawExpr *c_expr = NULL;
10033
  ObPlQueryRefRawExpr* sql = NULL;
10034
  ObCollationType collation_connection = CS_TYPE_INVALID;
10035
  OZ (stmt_factory_.allocate(PL_EXECUTE, current_block_, stmt));
10036
  CK (OB_NOT_NULL(execute_stmt = static_cast<ObPLExecuteStmt *>(stmt)));
10037
  CK (OB_NOT_NULL(sql = static_cast<ObPlQueryRefRawExpr *>(func.get_expr(sql_expr_index))));
10038
  // for SQL, construct an ObConstRawExpr from ObPlQueryRefRawExpr
10039
  OZ (ob_write_string(resolve_ctx_.allocator_, sql->get_ps_sql(), str_val));
10040
  OX (val.set_string(ObCharType, str_val));
10041
  OX (val.set_collation_level(CS_LEVEL_COERCIBLE));
10042
  OZ (current_block_->get_namespace().get_external_ns()->get_resolve_ctx().session_info_.get_collation_connection(collation_connection));
10043
  OX (val.set_collation_type(collation_connection));
10044
  OZ (expr_factory_.create_raw_expr(T_CHAR, c_expr));
10045
  OX (c_expr->set_value(val));
10046
  OZ (func.add_expr(c_expr));
10047
  OX (execute_stmt->set_sql(func.get_expr_count() - 1));
10048
  // for into
10049
  OZ (execute_stmt->add_into(into_expr_index, current_block_->get_namespace(), *func.get_expr(into_expr_index)));
10050
  // for using
10051
  if(OB_SUCC(ret)) {
10052
    for(int64_t param_pos = 0; param_pos < sql->get_param_count() && OB_SUCC(ret); param_pos++) {
10053
      for(int64_t using_pos = 0; using_pos < func.get_expr_count() && OB_SUCC(ret); using_pos++) {
10054
        if(func.get_expr(using_pos) == sql->get_param_expr(param_pos)) {
10055
          // CK (func.get_expr(using_pos)->get_expr_type() == T_QUESTIONMARK);
10056
          OZ (execute_stmt->get_using().push_back(InOutParam(using_pos, PL_PARAM_IN, OB_INVALID_INDEX)));
10057
          break;
10058
        } else {
10059
          CK (using_pos < func.get_expr_count() - 1);
10060
        }
10061
      }
10062
    }
10063
  }
10064
  OZ (current_block_->add_stmt(stmt));
10065
  LOG_INFO("now transform var_val to dynamic SQL!",K(ret), K(sql_expr_index), K(into_expr_index), K(str_val));
10066
  return ret;
10067
}
10068

10069
int ObPLResolver::transform_to_new_assign_stmt(ObIArray<int64_t> &transform_array, ObPLAssignStmt *&old_stmt)
10070
{
10071
  int ret = OB_SUCCESS;
10072
  if(!transform_array.empty()) {
10073
    ObPLStmt *stmt = NULL;
10074
    ObPLAssignStmt * new_assign_stmt = NULL;
10075
    OZ (stmt_factory_.allocate(PL_ASSIGN, current_block_, stmt));
10076
    CK (OB_NOT_NULL(new_assign_stmt = static_cast<ObPLAssignStmt *>(stmt)));
10077
    for(int64_t i = 0; i < transform_array.count() && OB_SUCC(ret); i++) {
10078
      OZ (new_assign_stmt->add_into(old_stmt->get_into_index(transform_array.at(i))));
10079
      OZ (new_assign_stmt->add_value(old_stmt->get_value_index(transform_array.at(i))));
10080
    }
10081
    OX (transform_array.reset());
10082
    OZ (current_block_->add_stmt(stmt));
10083
  }
10084
  return ret;
10085
}
10086

10087
int ObPLResolver::check_expr_can_pre_calc(ObRawExpr *expr, bool &pre_calc)
10088
{
10089
  int ret = OB_SUCCESS;
10090
  CK (OB_NOT_NULL(expr));
10091
  // 在SQL下可以提前计算的表达式,在PL下则不一定能提前计算, 如ROW_COUNT, ROW%COUNT
10092
  // 暂时没有统一的规则计算可以在PL端提前计算的表达式,因此暂时仅放开部分表达式
10093
  if (!(
10094
    (IS_CONST_TYPE(expr->get_expr_type()) && T_QUESTIONMARK != expr->get_expr_type())
10095
    || T_FUN_SYS_STR_TO_DATE == expr->get_expr_type()
10096
    || T_FUN_SYS_TO_DATE == expr->get_expr_type()
10097
    || T_FUN_COLUMN_CONV == expr->get_expr_type())) {
10098
    pre_calc = false;
10099
  }
10100
  for (int64_t i = 0; OB_SUCC(ret) && pre_calc && i < expr->get_param_count(); ++i) {
10101
    OZ (check_expr_can_pre_calc(expr->get_param_expr(i), pre_calc));
10102
  }
10103
  LOG_DEBUG("check_expr_can_pre_calc", K(pre_calc), K(ret), KPC(expr));
10104
  return ret;
10105
}
10106

10107
int ObPLResolver::replace_to_const_expr_if_need(ObRawExpr *&expr)
10108
{
10109
  int ret = OB_SUCCESS;
10110
  bool pre_calc = false;
10111
  CK (OB_NOT_NULL(expr));
10112
  LOG_DEBUG("start replaceto const expr if need", K(ret), KPC(expr));
10113
  if (OB_SUCC(ret) && expr->is_const_expr()) {
10114
    pre_calc = true;
10115
    OZ (check_expr_can_pre_calc(expr, pre_calc));
10116
  }
10117
  if (OB_SUCC(ret) && pre_calc && !expr->is_const_raw_expr()) {
10118
    ObObj result;
10119
    ObConstRawExpr *const_expr = NULL;
10120
    OZ (ObSPIService::spi_calc_raw_expr(&(resolve_ctx_.session_info_),
10121
                                        &(resolve_ctx_.allocator_),
10122
                                        expr,
10123
                                        &result));
10124
    OZ (expr_factory_.create_raw_expr(static_cast<ObItemType>(result.get_meta().get_type()),
10125
                                      const_expr));
10126
    CK (OB_NOT_NULL(const_expr));
10127
    OX (const_expr->set_value(result));
10128
    OX (expr = const_expr);
10129
  }
10130
  LOG_DEBUG("end replaceto const expr if need", K(ret), KPC(expr));
10131
  return ret;
10132
}
10133

10134
int ObPLResolver::resolve_columns(ObRawExpr *&expr, ObArray<ObQualifiedName> &columns, ObPLCompileUnitAST &unit_ast)
10135
{
10136
  int ret = OB_SUCCESS;
10137
  ObArray<ObRawExpr*> real_exprs;
10138
  for(int64_t i = 0; OB_SUCC(ret) && i < columns.count(); i++) {
10139
    ObQualifiedName &q_name = columns.at(i);
10140
    ObRawExpr *ref_expr = NULL;
10141
    OZ (resolve_qualified_identifier(q_name, columns, real_exprs, unit_ast, ref_expr),
10142
                                     K(q_name), K(columns), K(real_exprs), K(unit_ast), K(ref_expr));
10143
    CK (OB_NOT_NULL(ref_expr));
10144
    OZ (real_exprs.push_back(ref_expr), ref_expr);
10145
    OZ (ObRawExprUtils::replace_ref_column(expr, q_name.ref_expr_, ref_expr));
10146
    if (OB_SUCC(ret) && T_SP_CPARAM == expr->get_expr_type()) {
10147
      ObCallParamRawExpr* call_expr = static_cast<ObCallParamRawExpr*>(expr);
10148
      CK (ref_expr != expr);
10149
      CK (ref_expr->get_expr_type() != T_SP_CPARAM);
10150
      CK (OB_NOT_NULL(call_expr));
10151
      if (OB_SUCC(ret)) {
10152
        ObRawExpr *param_child = call_expr->get_expr();
10153
        if (OB_NOT_NULL(param_child)) {
10154
          if (param_child == q_name.ref_expr_) {
10155
            OX (call_expr->set_expr(ref_expr));
10156
          } else {
10157
            OZ (ObRawExprUtils::replace_ref_column(param_child, q_name.ref_expr_, ref_expr));
10158
          }
10159
        }
10160
      }
10161
    }
10162
    if (OB_SUCC(ret) && ref_expr->is_obj_access_expr()) { //ObObjAccessrawExpr需额外存储一份
10163
      OZ (unit_ast.add_obj_access_expr(ref_expr), q_name, ref_expr);
10164
    }
10165
  }
10166
  return ret;
10167
}
10168

10169
int ObPLResolver::resolve_raw_expr(const ParseNode &node,
10170
                                   sql::ObResolverParams &params,
10171
                                   ObRawExpr *&expr,
10172
                                   bool for_write,
10173
                                   const ObPLDataType *expected_type)
10174
{
10175
  int ret = OB_SUCCESS;
10176
  CK (OB_NOT_NULL(params.allocator_));
10177
  CK (OB_NOT_NULL(params.session_info_));
10178
  CK (OB_NOT_NULL(params.schema_checker_));
10179
  CK (OB_NOT_NULL(params.schema_checker_->get_schema_guard()));
10180
  CK (OB_NOT_NULL(params.sql_proxy_));
10181
  CK (OB_NOT_NULL(params.expr_factory_));
10182
  if (OB_FAIL(ret)) {
10183
  } else if (OB_ISNULL(params.secondary_namespace_)) {
10184
    HEAP_VAR(pl::ObPLFunctionAST, func_ast, *(params.allocator_)) {
10185
      ObPLStmtBlock *null_block = NULL;
10186
      ObPLPackageGuard package_guard(params.session_info_->get_effective_tenant_id());
10187
      ObPLResolver resolver(*(params.allocator_),
10188
                            *(params.session_info_),
10189
                            *(params.schema_checker_->get_schema_guard()),
10190
                            package_guard,
10191
                            *(params.sql_proxy_),
10192
                            *(params.expr_factory_),
10193
                            NULL,/*parent ns*/
10194
                            params.is_prepare_protocol_,
10195
                            false, /*check mode*/
10196
                            true, /*sql mode*/
10197
                            params.param_list_);
10198
      OZ (package_guard.init());
10199
      OZ (resolver.init(func_ast));
10200
      // build first namespace
10201
      OZ (resolver.make_block(func_ast, NULL, null_block));
10202
      OZ (resolver.resolve_expr(&node, func_ast, expr,
10203
                                resolver.combine_line_and_col(node.stmt_loc_),
10204
                                false, expected_type));
10205
      OZ (resolver.check_variable_accessible(expr, for_write));
10206
    }
10207
  } else {
10208
    HEAP_VAR(pl::ObPLFunctionAST, func_ast, *(params.allocator_)) {
10209
      ObPLBlockNS &ns = *(params.secondary_namespace_);
10210
      ObPLResolver resolver(*(params.allocator_),
10211
                            ns.get_external_ns()->get_resolve_ctx().session_info_,
10212
                            ns.get_external_ns()->get_resolve_ctx().schema_guard_,
10213
                            ns.get_external_ns()->get_resolve_ctx().package_guard_,
10214
                            ns.get_external_ns()->get_resolve_ctx().sql_proxy_,
10215
                            *(params.expr_factory_),
10216
                            ns.get_external_ns()->get_parent_ns(),
10217
                            params.is_prepare_protocol_,
10218
                            false, /*check mode*/
10219
                            true, /*sql mode*/
10220
                            params.param_list_);
10221
      OZ (resolver.init(func_ast));
10222
      OX (resolver.get_current_namespace() = ns);
10223
      OZ (resolver.resolve_expr(&node, func_ast, expr,
10224
                                resolver.combine_line_and_col(node.stmt_loc_),
10225
                                false, expected_type));
10226
      OZ (resolver.check_variable_accessible(expr, for_write));
10227
    }
10228
  }
10229
  return ret;
10230
}
10231

10232
int ObPLResolver::resolve_raw_expr(const ParseNode &node,
10233
                                   common::ObIAllocator &allocator,
10234
                                   ObRawExprFactory &expr_factory,
10235
                                   ObPLBlockNS &ns,
10236
                                   bool is_prepare_protocol,
10237
                                   ObRawExpr *&expr,
10238
                                   bool for_write)
10239
{
10240
  int ret = OB_SUCCESS;
10241
  CK (OB_NOT_NULL(ns.get_external_ns()));
10242
  if (OB_SUCC(ret)) {
10243
    ObArray<ObQualifiedName> columns;
10244
    ObArray<ObVarInfo> sys_vars;
10245
    ObArray<ObAggFunRawExpr*> aggr_exprs;
10246
    ObArray<ObWinFunRawExpr*> win_exprs;
10247
    ObArray<ObSubQueryInfo> sub_query_info;
10248
    ObArray<ObUDFInfo> udf_info;
10249
    ObArray<ObOpRawExpr*> op_exprs;
10250

10251
    ObPLResolver resolver(allocator,
10252
                          ns.get_external_ns()->get_resolve_ctx().session_info_,
10253
                          ns.get_external_ns()->get_resolve_ctx().schema_guard_,
10254
                          ns.get_external_ns()->get_resolve_ctx().package_guard_,
10255
                          ns.get_external_ns()->get_resolve_ctx().sql_proxy_,
10256
                          expr_factory,
10257
                          ns.get_external_ns()->get_parent_ns(),
10258
                          is_prepare_protocol,
10259
                          false,
10260
                          false,
10261
                          ns.get_external_ns()->get_resolve_ctx().params_.param_list_);
10262
    HEAP_VAR(pl::ObPLFunctionAST, func_ast, allocator) {
10263
      OC( (resolver.init)(func_ast) );
10264
      if (OB_SUCC(ret)) {
10265
        resolver.get_current_namespace() = ns;
10266

10267
        OZ (resolver.build_raw_expr(node,
10268
                                    expr,
10269
                                    columns,
10270
                                    sys_vars,
10271
                                    aggr_exprs,
10272
                                    win_exprs,
10273
                                    sub_query_info,
10274
                                    udf_info,
10275
                                    op_exprs,
10276
                                    is_prepare_protocol));
10277

10278
        for(int64_t i = 0; OB_SUCC(ret) && i < columns.count(); ++i) {
10279
          OZ (resolver.resolve_columns(expr, columns, static_cast<ObPLCompileUnitAST &>(func_ast)));
10280
        }
10281

10282
        // 该接口调用栈:
10283
        // resolve_into_variable_node -> resolve_external_expr -> resolve_raw_expr
10284
        // into variable 不支持udf， 这里报错处理
10285
        if (OB_SUCC(ret) && udf_info.count() > 0) {
10286
          ret = OB_ERR_UNEXPECTED;
10287
          LOG_WARN("into variable is not support udf", K(ret));
10288
        }
10289
      }
10290
      CK (OB_NOT_NULL(expr));
10291
      OZ (expr->extract_info());
10292
      OZ (expr->deduce_type(&ns.get_external_ns()->get_resolve_ctx().session_info_));
10293

10294
      OZ (resolver.check_variable_accessible(expr, for_write));
10295
    }
10296
  }
10297

10298
  if (OB_SUCC(ret) && expr->is_obj_access_expr()) {
10299
    OZ(expr->formalize(&ns.get_external_ns()->get_resolve_ctx().session_info_));
10300
    OZ (set_write_property(expr,
10301
                           expr_factory,
10302
                           &ns.get_external_ns()->get_resolve_ctx().session_info_,
10303
                           &ns.get_external_ns()->get_resolve_ctx().schema_guard_,
10304
                           for_write));
10305
  }
10306
  return ret;
10307
}
10308

10309
int ObPLResolver::init_udf_info_of_accessident(ObObjAccessIdent &access_ident)
10310
{
10311
  int ret = OB_SUCCESS;
10312
  ObUDFRawExpr *func_expr = NULL;
10313
  OX (new (&access_ident.udf_info_) ObUDFInfo());
10314
  OZ (expr_factory_.create_raw_expr(T_FUN_UDF, func_expr));
10315
  CK (OB_NOT_NULL(func_expr));
10316
  for (int64_t i = 0; OB_SUCC(ret) && i < access_ident.params_.count(); ++i) {
10317
    std::pair<ObRawExpr*, int64_t> &param = access_ident.params_.at(i);
10318
    if (0 == param.second) {
10319
      OZ (func_expr->add_param_expr(param.first));
10320
      OX (access_ident.udf_info_.udf_param_num_++);
10321
    } else {
10322
      break;
10323
    }
10324
  }
10325
  OX (func_expr->set_func_name(access_ident.access_name_));
10326
  OX (access_ident.udf_info_.ref_expr_ = func_expr);
10327
  return ret;
10328
}
10329

10330
int ObPLResolver::init_udf_info_of_accessidents(ObIArray<ObObjAccessIdent> &access_idents)
10331
{
10332
  int ret = OB_SUCCESS;
10333
  for (int64_t i = 0; OB_SUCC(ret) && i < access_idents.count(); ++i) {
10334
    OZ (init_udf_info_of_accessident(access_idents.at(i)));
10335
  }
10336
  return ret;
10337
}
10338

10339
int ObPLResolver::mock_self_param(bool need_rotate,
10340
                                  ObIArray<ObObjAccessIdent> &obj_access_idents,
10341
                                  ObIArray<ObObjAccessIdx> &self_access_idxs,
10342
                                  ObPLFunctionAST &func)
10343
{
10344
  int ret = OB_SUCCESS;
10345
  uint64_t acc_cnt = obj_access_idents.count();
10346
  ObRawExpr *self_arg = NULL;
10347
  if (!(self_access_idxs.count() > 0 &&
10348
        ObObjAccessIdx::IS_UDT_NS == self_access_idxs.at(self_access_idxs.count() - 1).access_type_)) {
10349
    if (self_access_idxs.at(self_access_idxs.count() - 1).is_udf_type()) {
10350
      OX (self_arg = self_access_idxs.at(self_access_idxs.count() - 1).get_sysfunc_);
10351
      CK (OB_NOT_NULL(self_arg));
10352
    } else {
10353
      OZ (make_var_from_access(self_access_idxs,
10354
                               expr_factory_,
10355
                               &resolve_ctx_.session_info_,
10356
                               &resolve_ctx_.schema_guard_,
10357
                               current_block_->get_namespace(),
10358
                               self_arg), K(obj_access_idents), K(self_access_idxs));
10359
      OZ (func.add_obj_access_expr(self_arg));
10360
    }
10361
    OZ (func.add_expr(self_arg));
10362
    OZ (obj_access_idents.at(acc_cnt - 1).params_.push_back(std::make_pair(self_arg, 0)));
10363
    if (OB_SUCC(ret) && need_rotate) {
10364
      std::rotate(obj_access_idents.at(acc_cnt - 1).params_.begin(),
10365
                  obj_access_idents.at(acc_cnt - 1).params_.begin()
10366
                    + obj_access_idents.at(acc_cnt - 1).params_.count() - 1,
10367
                  obj_access_idents.at(acc_cnt - 1).params_.end());
10368
    }
10369
  }
10370
  return ret;
10371
}
10372

10373
int ObPLResolver::resolve_inner_call(
10374
  const ParseNode *parse_tree, ObPLStmt *&stmt, ObPLFunctionAST &func)
10375
{
10376
  int ret = OB_SUCCESS;
10377
  CK (OB_NOT_NULL(parse_tree));
10378
  CK (OB_LIKELY(T_SP_INNER_CALL_STMT == parse_tree->type_));
10379
  CK (OB_LIKELY(1 == parse_tree->num_child_) || (3 == parse_tree->num_child_));
10380
  if (OB_SUCC(ret)) {
10381
    ObArray<ObObjAccessIdent> obj_access_idents;
10382
    ObArray<ObObjAccessIdx> access_idxs;
10383
    ObArray<ObObjAccessIdx> self_access_idxs;
10384
    ObArray<ObRawExpr *> expr_params;
10385
    if (1 == parse_tree->num_child_) {
10386
      OZ (resolve_obj_access_idents(*parse_tree->children_[0], obj_access_idents, func));
10387
      OZ (init_udf_info_of_accessidents(obj_access_idents));
10388
      for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_idents.count(); ++i) {
10389
        // TODO: distinguish coll(idx).proc() and func(arg1).proc()
10390
        bool is_routine = obj_access_idents.at(i).is_pl_udf()
10391
          || (obj_access_idents.at(i).params_.count() != 1 && obj_access_idents.at(i).has_brackets_);
10392
        if (i == obj_access_idents.count() - 1) {
10393
          if (access_idxs.count() > 0) {
10394
            if (access_idxs.at(access_idxs.count() - 1).access_type_ == ObObjAccessIdx::IS_DB_NS
10395
                || access_idxs.at(access_idxs.count() - 1).access_type_ == ObObjAccessIdx::IS_PKG_NS
10396
                || access_idxs.at(access_idxs.count() - 1).access_type_ == ObObjAccessIdx::IS_LABEL_NS
10397
                || access_idxs.at(access_idxs.count() - 1).access_type_ == ObObjAccessIdx::IS_UDT_NS
10398
                || access_idxs.at(access_idxs.count() - 1).access_type_ == ObObjAccessIdx::IS_DBLINK_PKG_NS) {
10399
              is_routine = true;
10400
            }
10401
          } else {
10402
            is_routine = true;
10403
          }
10404
        } else {
10405
          obj_access_idents.at(i).set_pl_udf();
10406
        }
10407
        int64_t idx_cnt = access_idxs.count();
10408
        OZ (resolve_access_ident(obj_access_idents.at(i),
10409
                                current_block_->get_namespace(),
10410
                                expr_factory_,
10411
                                &resolve_ctx_.session_info_,
10412
                                access_idxs,
10413
                                func,
10414
                                is_routine),
10415
                                K(access_idxs), K(i));
10416
        OZ (obj_access_idents.at(i).extract_params(0, expr_params));
10417
        OX (idx_cnt = (idx_cnt >= access_idxs.count()) ? 0 : idx_cnt);
10418
        if (OB_SUCC(ret)
10419
            && (expr_params.count() > 0 || obj_access_idents.at(i).has_brackets_)
10420
            && !access_idxs.at(idx_cnt).is_procedure()
10421
            && !access_idxs.at(idx_cnt).is_udf_type()
10422
            && !access_idxs.at(idx_cnt).is_system_procedure()
10423
            && !access_idxs.at(idx_cnt).is_type_method()
10424
            && (!access_idxs.at(idx_cnt).var_type_.is_composite_type() || 0 == expr_params.count())) {
10425
          ret = OB_ERR_OUT_OF_SCOPE;
10426
          LOG_WARN("PLS-00225: subprogram or cursor reference is out of scope", K(ret), K(access_idxs.at(access_idxs.count()-1)));
10427
          LOG_USER_ERROR(OB_ERR_OUT_OF_SCOPE, obj_access_idents.at(i).access_name_.length(), obj_access_idents.at(i).access_name_.ptr());
10428
        }
10429
        if (OB_SUCC(ret)
10430
            && obj_access_idents.count() >= 2
10431
            && i == (obj_access_idents.count() - 2)) {
10432
          OZ (self_access_idxs.assign(access_idxs));
10433
        }
10434
      }
10435
    } else {
10436
      OZ (resolve_dblink_idents(*parse_tree, obj_access_idents, func, access_idxs));
10437
      // PLFunction with dblink call statement cannot be added to plan cache
10438
      OX (func.set_can_cached(false));
10439
    }
10440

10441
    if (OB_SUCC(ret)) {
10442
      int64_t idx_cnt = access_idxs.count();
10443
      int64_t idents_cnt = obj_access_idents.count();
10444
      CK (OB_LIKELY(idx_cnt != 0));
10445
      if (OB_FAIL(ret)) {
10446
      } else if (access_idxs.at(idx_cnt - 1).is_system_procedure()) {
10447
        if (0 == access_idxs.at(idx_cnt - 1).var_name_.case_compare("RAISE_APPLICATION_ERROR")) {
10448
          ObPLRaiseAppErrorStmt *raise_stmt = NULL;
10449
          ObArray<ObRawExpr*> params;
10450
          OZ (stmt_factory_.allocate(PL_RAISE_APPLICATION_ERROR, current_block_, stmt));
10451
          CK (OB_NOT_NULL(raise_stmt = static_cast<ObPLRaiseAppErrorStmt *>(stmt)));
10452
          OZ (obj_access_idents.at(idents_cnt-1).extract_params(0, params));
10453
          for (int64_t  i = 0; OB_SUCC(ret) && i < params.count(); ++i) {
10454
            int64_t expr_idx = OB_INVALID_ID;
10455
            CK (OB_NOT_NULL(params.at(i)));
10456
            if (OB_SUCC(ret) && params.at(i)->get_expr_type() == T_SP_CPARAM) {
10457
              ret = OB_NOT_SUPPORTED;
10458
              LOG_WARN("not supported assign parameter yet", K(ret));
10459
              LOG_USER_ERROR(OB_NOT_SUPPORTED, "assign parameter in RAISE_APPLICATION_ERROR");
10460
            }
10461
            CK (has_exist_in_array(func.get_exprs(), params.at(i), &expr_idx));
10462
            OZ (raise_stmt->add_param(expr_idx));
10463
          }
10464
        } else {
10465
          ret = OB_ERR_UNEXPECTED;
10466
          LOG_WARN("only support raise application error as system procedure for now",
10467
                   K(ret), K(access_idxs), K(idx_cnt));
10468
        }
10469
      } else if (access_idxs.at(idx_cnt - 1).is_procedure()) {
10470
        ObPLCallStmt *call_stmt = NULL;
10471
        const ObIRoutineInfo *iroutine_info = access_idxs.at(idx_cnt - 1).routine_info_;
10472
        func.set_external_state();
10473
        if (OB_ISNULL(iroutine_info)) {
10474
          ret = OB_ERR_UNEXPECTED;
10475
          LOG_WARN("unexpected null routine pointer", K(ret), K(idx_cnt), K(access_idxs));
10476
        } else if ((iroutine_info->is_reads_sql_data() && func.get_compile_flag().compile_with_rnds())
10477
            || (iroutine_info->is_modifies_sql_data() && func.get_compile_flag().compile_with_wnds())) {
10478
          ret = OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA;
10479
          LOG_WARN("PLS-00452: Subprogram 'string' violates its associated pragma", K(ret), K(func.get_compile_flag()));
10480
          LOG_USER_ERROR(OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA, func.get_name().length(), func.get_name().ptr());
10481
        } else if (OB_FAIL(stmt_factory_.allocate(PL_CALL, current_block_, stmt))) {
10482
          LOG_WARN("failed to alloc stmt", K(ret));
10483
        } else if (OB_ISNULL(call_stmt = static_cast<ObPLCallStmt *>(stmt))) {
10484
          ret = OB_ERR_UNEXPECTED;
10485
          LOG_WARN("failed to cast stmt", K(ret));
10486
        } else if (access_idxs.at(idx_cnt-1).is_internal_procedure()) {
10487
          ObArray<ObRawExpr*> params;
10488
          const ObPLRoutineInfo *package_routine_info = static_cast<const ObPLRoutineInfo *>(access_idxs.at(idx_cnt-1).routine_info_);
10489
          CK (OB_NOT_NULL(package_routine_info));
10490
          if (OB_SUCC(ret)) {
10491
            call_stmt->set_proc_id(package_routine_info->get_id());
10492
            call_stmt->set_package_id(func.get_package_id());
10493
            OX (call_stmt->set_route_sql(package_routine_info->get_route_sql()));
10494
            if (package_routine_info->has_accessible_by_clause()) {
10495
              OZ (check_package_accessible(
10496
                current_block_, resolve_ctx_.schema_guard_, func.get_package_id()));
10497
            }
10498
            if (OB_SUCC(ret) && package_routine_info->is_udt_routine()) {
10499
              call_stmt->set_is_object_udf();
10500
            }
10501
            // mock udt udf's self param
10502
            if (OB_SUCC(ret)
10503
                && package_routine_info->is_udt_routine()
10504
                && !package_routine_info->is_udt_static_routine()) {
10505
              if (idents_cnt > 0 && obj_access_idents.at(idents_cnt - 1).udf_info_.is_udt_udf_) {
10506
                call_stmt->set_is_object_udf();
10507
              }
10508
              const ObIArray<ObPLRoutineParam *> &routine_params
10509
                                  = package_routine_info->get_params();
10510
              const ObPLRoutineParam *self_param = NULL;
10511
              int64_t self_param_pos = OB_INVALID_INDEX;
10512
              for (int64_t i = 0; i < routine_params.count(); ++i) {
10513
                if (routine_params.at(i)->is_self_param()) {
10514
                  self_param = routine_params.at(i);
10515
                  self_param_pos = i;
10516
                  break;
10517
                }
10518
              }
10519
              if (OB_NOT_NULL(self_param)) {
10520
                const ObIRoutineInfo* routine_info = NULL;
10521
                CK (0 == self_param_pos || self_param_pos == routine_params.count() - 1);
10522
                CK (OB_NOT_NULL(routine_info = access_idxs.at(idx_cnt - 1).routine_info_));
10523

10524
                if (OB_FAIL(ret)) {
10525
                } else if (routine_info->is_udt_routine()
10526
                           && !(routine_info->is_udt_static_routine() || routine_info->is_udt_cons())) {
10527
                  if (idx_cnt > 1 && idents_cnt > 1) {
10528
                    OZ (mock_self_param(0 == self_param_pos, obj_access_idents, self_access_idxs, func));
10529
                  } else {
10530
                    ObConstRawExpr *question_expr = NULL;
10531
                    OZ (expr_factory_.create_raw_expr(T_QUESTIONMARK, question_expr));
10532
                    CK (OB_NOT_NULL(question_expr));
10533
                    if (OB_SUCC(ret)) {
10534
                      ObObjParam val;
10535
                      ObExprResType type;
10536
                      val.set_unknown(0);
10537
                      val.set_param_meta();
10538
                      question_expr->set_value(val);
10539
                      type.set_ext();
10540
                      question_expr->set_result_type(type);
10541
                      OZ (question_expr->extract_info());
10542
                      OZ (question_expr->add_flag(IS_UDT_UDF_SELF_PARAM));
10543
                      OZ (obj_access_idents.at(idents_cnt - 1)
10544
                            .params_.push_back(std::make_pair(question_expr, 0)));
10545
                      OZ (func.add_expr(question_expr));
10546
                      if (OB_SUCC(ret) && 0 == self_param_pos) {
10547
                        std::rotate(obj_access_idents.at(idents_cnt-1).params_.begin(),
10548
                                obj_access_idents.at(idents_cnt-1).params_.begin()
10549
                                  + obj_access_idents.at(idents_cnt-1).params_.count() - 1,
10550
                                obj_access_idents.at(idents_cnt-1).params_.end());
10551
                      }
10552
                    }
10553
                  }
10554
                } else {
10555
                  ObConstRawExpr *null_expr = NULL;
10556
                  OZ (expr_factory_.create_raw_expr(T_NULL, null_expr));
10557
                  CK (OB_NOT_NULL(null_expr));
10558
                  OZ (null_expr->extract_info());
10559
                  OZ (null_expr->add_flag(IS_UDT_UDF_SELF_PARAM));
10560
                  OZ (obj_access_idents.at(idents_cnt - 1)
10561
                        .params_.push_back(std::make_pair(null_expr, 0)));
10562
                  OZ (func.add_expr(null_expr));
10563
                  if (OB_SUCC(ret) && 0 == self_param_pos) {
10564
                    std::rotate(obj_access_idents.at(idents_cnt-1).params_.begin(),
10565
                                obj_access_idents.at(idents_cnt-1).params_.begin()
10566
                                  + obj_access_idents.at(idents_cnt-1).params_.count() - 1,
10567
                                obj_access_idents.at(idents_cnt-1).params_.end());
10568
                  }
10569
                }
10570
              }
10571
            }
10572
            // end mock self param
10573
            OZ (obj_access_idents.at(idents_cnt-1).extract_params(0, params));
10574
            if (OB_FAIL(ret)){
10575
            } else if (package_routine_info->get_param_count() != 0) {
10576
              OZ (resolve_call_param_list(params, package_routine_info->get_params(), call_stmt, func));
10577
            } else if (params.count() != 0) {
10578
              ret = OB_INVALID_ARGUMENT_NUM;
10579
              LOG_WARN("ORA-06553:PLS-306:wrong number or types of arguments in call procedure",
10580
                       K(ret), K(params.count()), K(package_routine_info->get_param_count()));
10581
            }
10582
          }
10583
        } else if (access_idxs.at(idx_cnt - 1).is_external_procedure()) {
10584
          ObArray<ObRawExpr*> params;
10585
          const share::schema::ObRoutineInfo *schema_routine_info
10586
                     = static_cast<const ObRoutineInfo *>(access_idxs.at(idx_cnt - 1).routine_info_);
10587
          CK (OB_NOT_NULL(schema_routine_info));
10588
          OX (call_stmt->set_package_id(schema_routine_info->get_package_id()));
10589
          OX (call_stmt->set_dblink_id(schema_routine_info->get_dblink_id()));
10590
          if (OB_FAIL(ret)) {
10591
          } else if (OB_INVALID_ID == schema_routine_info->get_package_id()) {
10592
            call_stmt->set_proc_id(schema_routine_info->get_routine_id());
10593
          } else {
10594
            call_stmt->set_proc_id(schema_routine_info->get_subprogram_id());
10595
          }
10596
          OX (call_stmt->set_route_sql(schema_routine_info->get_route_sql()));
10597
          OZ (check_routine_accessible(
10598
            current_block_, resolve_ctx_.schema_guard_, *schema_routine_info));
10599
          if (OB_SUCC(ret)) {
10600
            const common::ObIArray<share::schema::ObRoutineParam*> &routine_params
10601
                                                     = schema_routine_info->get_routine_params();
10602
            int64_t idents_cnt = obj_access_idents.count();
10603
            if (schema_routine_info->is_udt_routine()) {
10604
              call_stmt->set_is_object_udf();
10605
            }
10606
            if (OB_SUCC(ret) && !schema_routine_info->is_udt_static_routine()) {
10607
              if (idents_cnt > 1 && idx_cnt > 1) {
10608
                // call_stmt->set_is_object_udf();
10609
                const ObRoutineParam *self_param = NULL;
10610
                int64_t self_param_pos = OB_INVALID_INDEX;
10611
                for (int64_t i = 0; i < routine_params.count(); ++i) {
10612
                  if (routine_params.at(i)->is_self_param()) {
10613
                    self_param = routine_params.at(i);
10614
                    self_param_pos = i;
10615
                    break;
10616
                  }
10617
                }
10618
                // member procedure can be used as static procedure, if pass correct argument
10619
                if (OB_NOT_NULL(self_param)) {
10620
                  CK (0 == self_param_pos || self_param_pos == routine_params.count() - 1);
10621
                  OZ(mock_self_param(0 == self_param_pos, obj_access_idents, self_access_idxs, func));
10622
                }
10623
              }
10624
            }
10625
            OZ (obj_access_idents.at(idents_cnt - 1).extract_params(0, params));
10626
            if (routine_params.count() != 0) {
10627
              OZ (resolve_call_param_list(params, routine_params, call_stmt, func));
10628
            } else if (params.count() != 0) {
10629
              ret = OB_INVALID_ARGUMENT_NUM;
10630
              LOG_WARN("ORA-06553:PLS-306:wrong number or types of arguments in call procedure",
10631
                       K(ret), K(params.count()), K(schema_routine_info->get_param_count()));
10632
            }
10633
          }
10634
        } else if (access_idxs.at(idx_cnt - 1).is_nested_procedure()) {
10635
          ObArray<ObRawExpr*> params;
10636
          const ObPLRoutineInfo *root_routine_info
10637
              = static_cast<const ObPLRoutineInfo *>(access_idxs.at(idx_cnt-1).routine_info_);
10638
          CK (OB_NOT_NULL(root_routine_info));
10639
          if (OB_SUCC(ret)) {
10640
            call_stmt->set_package_id(func.get_package_id());
10641
            call_stmt->set_proc_id(root_routine_info->get_parent_id());
10642
            OX (call_stmt->set_route_sql(root_routine_info->get_route_sql()));
10643
            OZ (call_stmt->set_subprogram_path(root_routine_info->get_subprogram_path()));
10644
            OZ (obj_access_idents.at(idx_cnt-1).extract_params(0, params));
10645
            if (root_routine_info->get_param_count() != 0) {
10646
              OZ (resolve_call_param_list(params, root_routine_info->get_params(), call_stmt, func));
10647
            } else if (params.count() != 0) {
10648
              ret = OB_INVALID_ARGUMENT_NUM;
10649
              LOG_WARN("ORA-06553:PLS-306:wrong number or types of arguments in call procedure",
10650
                       K(ret), K(params.count()), K(root_routine_info->get_param_count()));
10651
            }
10652
          }
10653
        } else {
10654
          ret = OB_NOT_SUPPORTED;
10655
          LOG_WARN("not support procedure type", K(access_idxs.at(idx_cnt - 1)), K(ret));
10656
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "procedure type");
10657
          LOG_USER_ERROR(OB_NOT_SUPPORTED, const_cast<char *> (func.get_name().ptr()));
10658
        }
10659
      } else if (access_idxs.at(idx_cnt - 1).is_type_method()) {
10660
        ObRawExpr *expr = NULL;
10661
        ObPLDataType *type = NULL;
10662
        int64_t expr_idx = OB_INVALID_INDEX, x = OB_INVALID_INDEX, y = OB_INVALID_INDEX;
10663
        // for now, support extend,delete only, need check readonly prop
10664
        OZ (check_variable_accessible(current_block_->get_namespace(), access_idxs, true));
10665
        OZ (make_var_from_access(access_idxs, expr_factory_,
10666
                     &resolve_ctx_.session_info_, &resolve_ctx_.schema_guard_,
10667
                     get_current_namespace(), expr, false));
10668
        OZ (func.add_obj_access_expr(expr));
10669
        OZ (func.add_expr(expr));
10670
        CK (OB_NOT_NULL(type = &(access_idxs.at(access_idxs.count() - 2).elem_type_)));
10671
        CK (type->is_collection_type());
10672
        OZ (type->get_all_depended_user_type(get_resolve_ctx(), get_current_namespace()));
10673
        CK (OB_INVALID_ID != (expr_idx = func.get_expr_count()-1));
10674
        if (OB_SUCC(ret)) {
10675
          if (type->is_associative_array_type()
10676
              && 0 == access_idxs.at(access_idxs.count()-1).var_name_.case_compare("extend")) {
10677
            ret = OB_ERR_CALL_WRONG_ARG;
10678
            LOG_USER_ERROR(OB_ERR_CALL_WRONG_ARG,
10679
                           ObString("EXTEND").length(), ObString("EXTEND").ptr());
10680
          } else if (!access_idxs.at(access_idxs.count()-1).type_method_params_.empty()) {
10681
            x = access_idxs.at(access_idxs.count()-1).type_method_params_.at(0);
10682
            if (2 == access_idxs.at(access_idxs.count()-1).type_method_params_.count()) {
10683
              y = access_idxs.at(access_idxs.count()-1).type_method_params_.at(1);
10684
            }
10685
          } else if (0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("extend")) {
10686
            ObConstRawExpr *expr = NULL;
10687
            OZ (ObRawExprUtils::build_const_int_expr(expr_factory_, ObIntType, 1, expr));
10688
            CK (OB_NOT_NULL(expr));
10689
            OZ (func.add_expr(expr));
10690
            if (OB_SUCC(ret)) {
10691
              x = func.get_expr_count() - 1;
10692
            }
10693
          }
10694
        }
10695
        if (OB_SUCC(ret)) {
10696
          CK (0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("extend")
10697
              || 0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("delete")
10698
              || 0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("trim"));
10699
          if (0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("extend")) {
10700
            ObPLExtendStmt *extend_stmt = NULL;
10701
            OZ (stmt_factory_.allocate(PL_EXTEND, current_block_, stmt));
10702
            CK (OB_NOT_NULL(extend_stmt = static_cast<ObPLExtendStmt *>(stmt)));
10703
            if (OB_SUCC(ret)) {
10704
              extend_stmt->set_extend(expr_idx);
10705
              extend_stmt->set_ni(x, y);
10706
            }
10707
          } else if (0 == access_idxs.at(idx_cnt-1).var_name_.case_compare("delete")){
10708
            ObPLDeleteStmt *delete_stmt = NULL;
10709
            OZ (stmt_factory_.allocate(PL_DELETE, current_block_, stmt));
10710
            CK (OB_NOT_NULL(delete_stmt = static_cast<ObPLDeleteStmt *>(stmt)));
10711
            if (OB_SUCC(ret)) {
10712
              delete_stmt->set_delete(expr_idx);
10713
              delete_stmt->set_mn(x, y);
10714
            }
10715
          } else {
10716
            ObPLTrimStmt *trim_stmt = NULL;
10717
            OZ (stmt_factory_.allocate(PL_TRIM, current_block_, stmt));
10718
            CK (OB_NOT_NULL(trim_stmt = static_cast<ObPLTrimStmt *>(stmt)));
10719
            if (OB_SUCC(ret)) {
10720
              trim_stmt->set_trim(expr_idx);
10721
              trim_stmt->set_n(x);
10722
            }
10723
          }
10724
        }
10725
      } else {
10726
        ret = OB_NOT_SUPPORTED;
10727
        LOG_WARN("not support inner call function type", K(ret), K(access_idxs.at(idx_cnt - 1)));
10728
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "inner call function type");
10729
        LOG_USER_ERROR(OB_NOT_SUPPORTED, const_cast<char *> (func.get_name().ptr()));
10730
      }
10731
    }
10732
  }
10733

10734
  return ret;
10735
}
10736

10737
int ObPLResolver::resolve_obj_access_node(const ParseNode &node,
10738
                                          ObSQLSessionInfo &session_info,
10739
                                          ObRawExprFactory &expr_factory,
10740
                                          ObSchemaGetterGuard &schema_guard,
10741
                                          ObMySQLProxy &sql_proxy,
10742
                                          ObIArray<ObObjAccessIdent> &obj_access_idents,
10743
                                          ObIArray<ObObjAccessIdx>& access_idxs)
10744
{
10745
  int ret = OB_SUCCESS;
10746
  pl::ObPLPackageGuard package_guard(session_info.get_effective_tenant_id());
10747
  ObArenaAllocator allocator(ObModIds::OB_MODULE_PAGE_ALLOCATOR,
10748
                             OB_MALLOC_NORMAL_BLOCK_SIZE,
10749
                             MTL_ID());
10750
  // fake resolve_ctx, we only use session_info, schema_guard
10751
  ObPLResolveCtx resolve_ctx(
10752
    allocator, session_info, schema_guard, package_guard, *(GCTX.sql_proxy_), false);
10753
  ObPLExternalNS external_ns(resolve_ctx, NULL);
10754
  CK (T_SP_OBJ_ACCESS_REF == node.type_);
10755
  OZ (package_guard.init());
10756
  OZ (ObPLResolver::resolve_obj_access_idents(node, expr_factory, obj_access_idents, session_info));
10757
  for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_idents.count(); ++i) {
10758
    OZ (ObPLResolver::resolve_access_ident(obj_access_idents.at(i),
10759
                                           external_ns,
10760
                                           access_idxs));
10761
  }
10762
  if (OB_FAIL(ret)) {
10763
    record_error_line(const_cast<const ObStmtNodeTree*>(&node), session_info);
10764
  }
10765
  return ret;
10766
}
10767

10768
int ObPLResolver::resolve_cparam_list_simple(const ParseNode &node,
10769
                                             ObRawExprFactory &expr_factory,
10770
                                             ObIArray<ObObjAccessIdent> &obj_access_idents)
10771
{
10772
  int ret = OB_SUCCESS;
10773
  CK (T_SP_CPARAM_LIST == node.type_);
10774
  for (int64_t i = 0; OB_SUCC(ret) && i < node.num_child_; ++i) {
10775
    const ParseNode* child_node = node.children_[i];
10776
    CK (OB_NOT_NULL(child_node));
10777
    if (OB_FAIL(ret)) {
10778
    } else if (child_node->type_ != T_INT) {
10779
      ret = OB_NOT_SUPPORTED;
10780
      LOG_WARN("not supported T_SP_CPARAM_LIST in resolve_obj_access_idents_sample",
10781
               K(ret), K(child_node->type_));
10782
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "T_SP_CPARAM_LIST in resolve_obj_access_idents_sample");
10783
    } else {
10784
      ObConstRawExpr *expr = NULL;
10785
      OZ (ObRawExprUtils::build_const_int_expr(
10786
        expr_factory, ObIntType, child_node->value_, expr));
10787
      CK (OB_NOT_NULL(expr));
10788
      OZ (obj_access_idents.at(obj_access_idents.count()-1)
10789
      .params_.push_back(std::make_pair(static_cast<ObRawExpr*>(expr), 0)));
10790
    }
10791
  }
10792
  return ret;
10793
}
10794

10795
// resolve obj access idents without T_SP_CPARAM_LIST
10796
int ObPLResolver::resolve_obj_access_idents(const ParseNode &node,
10797
                                            ObRawExprFactory &expr_factory,
10798
                                            ObIArray<ObObjAccessIdent> &obj_access_idents,
10799
                                            ObSQLSessionInfo &session_info)
10800
{
10801
  int ret = OB_SUCCESS;
10802
  CK (OB_LIKELY(node.type_ == T_SP_OBJ_ACCESS_REF),
10803
      OB_LIKELY(node.num_child_ == 2),
10804
      OB_NOT_NULL(node.children_[0]),
10805
      OB_LIKELY(T_SP_ACCESS_NAME == node.children_[0]->type_
10806
                || T_IDENT == node.children_[0]->type_
10807
                || T_SP_CPARAM_LIST == node.children_[0]->type_),
10808
      OB_LIKELY((0 == obj_access_idents.count() && T_SP_ACCESS_NAME == node.children_[0]->type_)
10809
                || obj_access_idents.count() != 0));
10810
#define PROCESS_IDENT_NODE(node) \
10811
  if (OB_SUCC(ret) && T_IDENT == node->type_) { \
10812
    ObString ident_name(static_cast<int32_t>(node->str_len_), \
10813
                        node->str_value_); \
10814
    ObObjAccessIdent access_ident(ident_name); \
10815
    OZ(obj_access_idents.push_back(access_ident)); \
10816
  }
10817
#define PROCESS_CPARAM_LIST_NODE(node) \
10818
  if (OB_SUCC(ret) && T_SP_CPARAM_LIST == node->type_) { \
10819
    OZ (resolve_cparam_list_simple(*node, expr_factory, obj_access_idents)); \
10820
  }
10821
#define PROCESS_ACCESS_NAME(node) \
10822
  if (OB_SUCC(ret) && T_SP_ACCESS_NAME == node->type_) { \
10823
    for (int i = 0; OB_SUCC(ret) && i < node->num_child_; i++) { \
10824
      if (OB_NOT_NULL(node->children_[i])) { \
10825
        ObString ident_name(static_cast<int32_t>(node->children_[i]->str_len_), \
10826
                            node->children_[i]->str_value_); \
10827
        ObObjAccessIdent access_ident(ident_name); \
10828
        OZ (obj_access_idents.push_back(access_ident)); \
10829
      } \
10830
    } \
10831
  }
10832
  PROCESS_IDENT_NODE(node.children_[0]);
10833
  PROCESS_CPARAM_LIST_NODE(node.children_[0]);
10834
  PROCESS_ACCESS_NAME(node.children_[0]);
10835

10836
  if (OB_SUCC(ret) && OB_NOT_NULL(node.children_[1])) {
10837
    CK (T_IDENT == node.children_[1]->type_
10838
        || T_SP_CPARAM_LIST == node.children_[1]->type_
10839
        || T_SP_OBJ_ACCESS_REF == node.children_[1]->type_);
10840
    PROCESS_IDENT_NODE(node.children_[1]);
10841
    PROCESS_CPARAM_LIST_NODE(node.children_[1]);
10842

10843
    if (OB_SUCC(ret) && T_SP_OBJ_ACCESS_REF == node.children_[1]->type_) {
10844
      OZ (resolve_obj_access_idents(*(node.children_[1]), expr_factory, obj_access_idents, session_info));
10845
    }
10846
  }
10847
  if (OB_FAIL(ret)) {
10848
    record_error_line(const_cast<const ObStmtNodeTree*>(&node), session_info);
10849
  }
10850
#undef PROCESS_IDENT_NODE
10851
#undef PROCESS_CPARAM_LIST_NODE
10852
#undef PROCESS_ACCESS_NAME
10853
  return ret;
10854
}
10855

10856
int ObPLResolver::resolve_obj_access_idents(const ParseNode &node,
10857
                                            ObIArray<ObObjAccessIdent> &obj_access_idents,
10858
                                            ObPLCompileUnitAST &func)
10859
{
10860
  int ret = OB_SUCCESS;
10861
  CK (OB_LIKELY(T_SP_OBJ_ACCESS_REF == node.type_));
10862
  CK (OB_LIKELY(2 == node.num_child_));
10863
  if (OB_SUCC(ret) && OB_ISNULL(node.children_[0])) {
10864
    ret = OB_ERR_OUT_OF_SCOPE;
10865
    LOG_WARN("PLS-00225: subprogram or cursor reference is out of scope", K(ret));
10866
  }
10867
  if (OB_SUCC(ret)) {
10868
    if (0 == obj_access_idents.count()
10869
        && T_SP_ACCESS_NAME != node.children_[0]->type_
10870
        && T_QUESTIONMARK != node.children_[0]->type_) {
10871
      ret = OB_ERR_UNEXPECTED;
10872
      LOG_WARN("node type invalid", K(node.children_[0]->type_), K(ret));
10873
    } else if (T_IDENT == node.children_[0]->type_) {
10874
      ObString ident_name(static_cast<int32_t>(node.children_[0]->str_len_), node.children_[0]->str_value_);
10875
      ObObjAccessIdent access_ident(ident_name);
10876
      if (OB_FAIL(obj_access_idents.push_back(access_ident))) {
10877
        LOG_WARN("push back access ident failed", K(ret), K(access_ident));
10878
      }
10879
    } else if (T_QUESTIONMARK == node.children_[0]->type_) {
10880
      if (obj_access_idents.count() > 0) {
10881
        ret = OB_ERR_UNEXPECTED;
10882
        LOG_WARN("quesitonmark in obj access ref muse be top node.", K(ret), K(obj_access_idents));
10883
      } else {
10884
        ObObjAccessIdent ident(ObString(""), node.children_[0]->value_);
10885
        OX (ident.set_pl_var());
10886
        OZ (obj_access_idents.push_back(ident));
10887
      }
10888
    } else if (T_SP_ACCESS_NAME == node.children_[0]->type_) {
10889
      for (int i = 0; OB_SUCC(ret) && i < node.children_[0]->num_child_; i++) {
10890
        if (OB_NOT_NULL(node.children_[0]->children_[i])) {
10891
          ObString ident_name(static_cast<int32_t>(node.children_[0]->children_[i]->str_len_), node.children_[0]->children_[i]->str_value_);
10892
          ObObjAccessIdent access_ident(ident_name);
10893
          if (OB_FAIL(obj_access_idents.push_back(access_ident))) {
10894
            LOG_WARN("push back access ident failed", K(ret));
10895
          }
10896
        }
10897
      }
10898
    } else if (T_SP_CPARAM_LIST == node.children_[0]->type_) {
10899
      ParseNode *params_node = node.children_[0];
10900
      ObObjAccessIdent param_access;
10901
      bool current_params = obj_access_idents.count() > 0
10902
              && !obj_access_idents.at(obj_access_idents.count()-1).access_name_.empty()
10903
              && obj_access_idents.at(obj_access_idents.count()-1).params_.empty();
10904
      obj_access_idents.at(obj_access_idents.count() -1).has_brackets_ = true;
10905
      for (int64_t param_idx = 0; OB_SUCC(ret) && param_idx < params_node->num_child_; ++param_idx) {
10906
        ObRawExpr *expr = NULL;
10907
        if (OB_FAIL(resolve_expr(params_node->children_[param_idx], func, expr,
10908
                            combine_line_and_col(params_node->children_[param_idx]->stmt_loc_)))) {
10909
          LOG_WARN("failed to resolve expr", K(ret));
10910
        } else {
10911
          std::pair<ObRawExpr*, int64_t> param(expr, 0);
10912
          if (current_params) {
10913
            if (OB_FAIL(obj_access_idents.at(obj_access_idents.count()-1).params_.push_back(param))) {
10914
              LOG_WARN("push back expr failed", K(ret));
10915
            }
10916
          } else {
10917
            if (OB_FAIL(param_access.params_.push_back(param))) {
10918
              LOG_WARN("push back access ident failed", K(ret));
10919
            }
10920
          }
10921
        }
10922
      }
10923
      if (OB_SUCC(ret) && !param_access.params_.empty()) {
10924
        if (OB_FAIL(obj_access_idents.push_back(param_access))) {
10925
          LOG_WARN("push back access ident failed", K(ret));
10926
        }
10927
      }
10928
    } else {
10929
      ret = OB_ERR_UNEXPECTED;
10930
      LOG_WARN("Invalid node type", K(node.children_[0]->type_), K(ret));
10931
    }
10932
  }
10933
  if (OB_SUCC(ret)) {
10934
    if (OB_NOT_NULL(node.children_[1])) {
10935
      if (T_IDENT == node.children_[1]->type_) {
10936
        ObString ident_name(static_cast<int32_t>(node.children_[1]->str_len_), node.children_[1]->str_value_);
10937
        ObObjAccessIdent access_ident(ident_name);
10938
        if (OB_FAIL(obj_access_idents.push_back(access_ident))) {
10939
          LOG_WARN("push back access ident failed", K(ret));
10940
        }
10941
      } else if (T_SP_CPARAM_LIST == node.children_[1]->type_) {
10942
        ParseNode *params_node = node.children_[1];
10943
        ObObjAccessIdent param_access;
10944
        ObIArray<std::pair<ObRawExpr*, int64_t>> &current_params
10945
            = obj_access_idents.at(obj_access_idents.count()-1).params_;
10946
        int64_t current_level = current_params.empty()
10947
            ? 0 : current_params.at(current_params.count() - 1).second + 1;
10948
        obj_access_idents.at(obj_access_idents.count() - 1).has_brackets_ = true;
10949
        for (int64_t param_idx = 0; OB_SUCC(ret) && param_idx < params_node->num_child_; ++param_idx) {
10950
          ObRawExpr *expr = NULL;
10951
          if (OB_FAIL(resolve_expr(params_node->children_[param_idx], func, expr,
10952
                            combine_line_and_col(params_node->children_[param_idx]->stmt_loc_)))) {
10953
            LOG_WARN("failed to resolve expr", K(ret));
10954
          } else {
10955
            std::pair<ObRawExpr*, int64_t> param(expr, current_level);
10956
            if (T_IDENT == node.children_[0]->type_
10957
                || T_SP_ACCESS_NAME == node.children_[0]->type_
10958
                || T_SP_CPARAM_LIST == node.children_[0]->type_
10959
                || T_QUESTIONMARK == node.children_[0]->type_) {
10960
              if (OB_FAIL(obj_access_idents.at(obj_access_idents.count()-1).params_.push_back(param))) {
10961
                LOG_WARN("push back access ident failed", K(ret));
10962
              }
10963
            } else {
10964
              if (OB_FAIL(param_access.params_.push_back(param))) {
10965
                LOG_WARN("push back access ident failed", K(ret));
10966
              }
10967
            }
10968
          }
10969
        }
10970
        if (OB_SUCC(ret) && !param_access.params_.empty()) {
10971
          if (OB_FAIL(obj_access_idents.push_back(param_access))) {
10972
            LOG_WARN("push back access ident failed", K(ret));
10973
          }
10974
        }
10975
      } else if (T_SP_OBJ_ACCESS_REF == node.children_[1]->type_) {
10976
        if (OB_FAIL(resolve_obj_access_idents(*(node.children_[1]), obj_access_idents, func))) {
10977
          LOG_WARN("resolve obj access idents failed", K(ret));
10978
        }
10979
      } else {
10980
        ret = OB_ERR_UNEXPECTED;
10981
        LOG_WARN("Invalid node type", K(node.children_[1]->type_), K(ret));
10982
      }
10983
    }
10984
  }
10985
  return ret;
10986
}
10987

10988
int ObPLResolver::resolve_dblink_idents(const ParseNode &node,
10989
                                        common::ObIArray<ObObjAccessIdent> &obj_access_idents,
10990
                                        ObPLCompileUnitAST &func,
10991
                                        common::ObIArray<ObObjAccessIdx> &access_idexs)
10992
{
10993
  int ret = OB_SUCCESS;
10994
  UNUSED(func);
10995
  ObString dblink_name;
10996
  CK (OB_LIKELY(3 == node.num_child_));
10997
  CK (OB_LIKELY(OB_NOT_NULL(node.children_[0])) && OB_LIKELY(OB_NOT_NULL(node.children_[1])));
10998
  CK (OB_LIKELY(T_SP_ACCESS_NAME == node.children_[0]->type_));
10999
  CK (OB_LIKELY(T_DBLINK_NAME == node.children_[1]->type_));
11000
  for (int64_t i = 0; OB_SUCC(ret) && i < node.children_[0]->num_child_; i++) {
11001
    if (OB_NOT_NULL(node.children_[0]->children_[i])) {
11002
        ObString ident_name(static_cast<int32_t>(node.children_[0]->children_[i]->str_len_),
11003
                            node.children_[0]->children_[i]->str_value_);
11004
        ObObjAccessIdent access_ident(ident_name);
11005
        if (OB_FAIL(obj_access_idents.push_back(access_ident))) {
11006
          LOG_WARN("push back access ident failed", K(ret));
11007
      }
11008
    }
11009
  }
11010
  CK (obj_access_idents.count() >= 1 && obj_access_idents.count() <= 3);
11011
  CK (1 == node.children_[1]->num_child_ && OB_NOT_NULL(node.children_[1]->children_[0]));
11012
  OX (dblink_name.assign_ptr(node.children_[1]->children_[0]->str_value_,
11013
                             static_cast<int32_t>(node.children_[1]->children_[0]->str_len_)));
11014
  if (OB_SUCC(ret) && OB_NOT_NULL(node.children_[2])) {
11015
    ParseNode *params_node = node.children_[2];
11016
    ObObjAccessIdent param_access;
11017
    for (int64_t param_idx = 0; OB_SUCC(ret) && param_idx < params_node->num_child_; ++param_idx) {
11018
      ObRawExpr *expr = NULL;
11019
      if (OB_FAIL(resolve_expr(params_node->children_[param_idx], func, expr,
11020
                               combine_line_and_col(params_node->children_[param_idx]->stmt_loc_)))) {
11021
        LOG_WARN("failed to resolve expr", K(ret));
11022
      } else {
11023
        std::pair<ObRawExpr*, int64_t> param(expr, 0);
11024
        if (T_IDENT == node.children_[0]->type_
11025
            || T_SP_ACCESS_NAME == node.children_[0]->type_) {
11026
          if (OB_FAIL(obj_access_idents.at(obj_access_idents.count()-1).params_.push_back(param))) {
11027
            LOG_WARN("push back access ident failed", K(ret));
11028
          }
11029
        } else {
11030
          if (OB_FAIL(param_access.params_.push_back(param))) {
11031
            LOG_WARN("push back access ident failed", K(ret));
11032
          }
11033
        }
11034
      }
11035
    }
11036
    if (OB_SUCC(ret) && !param_access.params_.empty()) {
11037
      if (OB_FAIL(obj_access_idents.push_back(param_access))) {
11038
        LOG_WARN("push back access ident failed", K(ret));
11039
      }
11040
    }
11041
  }
11042

11043
  if (OB_SUCC(ret)) {
11044
    uint64_t dblink_id;
11045
    uint64_t cnt = obj_access_idents.count();
11046
    uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
11047
    common::ObArray<ObRawExpr *> expr_params;
11048
    const ObIRoutineInfo *routine_info = NULL;
11049
    ObString empty_str("");
11050
    ObString &routine_name = obj_access_idents.at(cnt - 1).access_name_;
11051
    ObString &pkg_name = (cnt >= 2 ? obj_access_idents.at(cnt - 2).access_name_ : empty_str);
11052
    ObString &db_name = (cnt == 3 ? obj_access_idents.at(0).access_name_ : empty_str);
11053
    OZ (obj_access_idents.at(cnt - 1).extract_params(0, expr_params));
11054
    // OZ (resolve_ctx_.schema_guard_.get_dblink_id(tenant_id, dblink_name, dblink_id));
11055
    // OV (OB_INVALID_ID != dblink_id, OB_DBLINK_NOT_EXIST_TO_ACCESS, dblink_id);
11056
    // OZ (resolve_ctx_.schema_guard_.get_dblink_user(tenant_id, dblink_name, db_name, resolve_ctx_.allocator_));
11057
    OZ (resolve_dblink_routine(resolve_ctx_, dblink_name, db_name, pkg_name,
11058
                                routine_name, expr_params, routine_info));
11059
    if (OB_SUCC(ret) && OB_NOT_NULL(routine_info)) {
11060
      ObPLDataType proc_pl_data_type;
11061
      ObObjAccessIdx::AccessType proc_type = ObObjAccessIdx::AccessType::IS_EXTERNAL_PROC;
11062
      int64_t access_value = reinterpret_cast<int64_t>(routine_info);
11063
      ObObjAccessIdx access_idx;
11064
      new (&access_idx)ObObjAccessIdx(proc_pl_data_type, proc_type, routine_name, proc_pl_data_type, access_value);
11065
      OZ (access_idexs.push_back(access_idx));
11066
    }
11067
  }
11068

11069
  return ret;
11070
}
11071

11072
int ObPLResolver::resolve_dblink_routine(ObPLResolveCtx &resolve_ctx,
11073
                                         const ObString &dblink_name,
11074
                                         const ObString &db_name,
11075
                                         const ObString &pkg_name,
11076
                                         const ObString &routine_name,
11077
                                         const common::ObIArray<sql::ObRawExpr *> &expr_params,
11078
                                         const ObIRoutineInfo *&routine_info)
11079
{
11080
  int ret = OB_SUCCESS;
11081
  ObSEArray<const ObIRoutineInfo*, 8> routine_infos;
11082
  const share::schema::ObIRoutineInfo *i_routine_info = NULL;
11083
  OZ (resolve_ctx.package_guard_.dblink_guard_.get_routine_infos_with_synonym(resolve_ctx.session_info_,
11084
        resolve_ctx.schema_guard_, dblink_name, db_name, pkg_name, routine_name, routine_infos));
11085

11086
  if (OB_SUCC(ret) && routine_infos.count() > 0) {
11087
    OZ (ObResolverUtils::pick_routine(resolve_ctx, expr_params, routine_infos, i_routine_info));
11088
    // OX (routine_info = static_cast<const share::schema::ObRoutineInfo*>(i_routine_info));
11089
    LOG_DEBUG("debug for pick routine info", K(ret), K(db_name), K(pkg_name),
11090
              K(routine_name), K(expr_params), KPC(routine_info));
11091
    if (OB_SUCC(ret)) {
11092
      routine_info = i_routine_info;
11093
    }
11094
  }
11095
  if (OB_SUCC(ret) && OB_ISNULL(routine_info)) {
11096
    ret = OB_ERR_NOT_VALID_ROUTINE_NAME;
11097
    LOG_WARN("not a valid function or procedure name", K(ret), K(dblink_name),
11098
              K(db_name), K(pkg_name), K(routine_name));
11099
  }
11100
  return ret;
11101
}
11102

11103
int ObPLResolver::resolve_dblink_routine_with_synonym(ObPLResolveCtx &resolve_ctx,
11104
                                                      const uint64_t pkg_syn_id,
11105
                                                      const ObString &routine_name,
11106
                                                      const common::ObIArray<sql::ObRawExpr *> &expr_params,
11107
                                                      const ObIRoutineInfo *&routine_info)
11108
{
11109
  int ret = OB_SUCCESS;
11110
#ifdef OB_BUILD_ORACLE_PL
11111
  ObString dblink_name;
11112
  ObString db_name;
11113
  ObString pkg_name;
11114
  ObSchemaChecker checker;
11115
  OZ (checker.init(resolve_ctx.schema_guard_, resolve_ctx.session_info_.get_sessid()));
11116
  OZ (ObPLDblinkUtil::separate_name_from_synonym(checker, resolve_ctx.allocator_,
11117
                                                 resolve_ctx.session_info_.get_effective_tenant_id(),
11118
                                                 resolve_ctx.session_info_.get_database_name(),
11119
                                                 pkg_syn_id, dblink_name, db_name, pkg_name));
11120
  OZ (ObPLResolver::resolve_dblink_routine(resolve_ctx, dblink_name, db_name, pkg_name,
11121
                                           routine_name, expr_params, routine_info),
11122
                                           dblink_name, db_name, pkg_name);
11123
#endif
11124
  return ret;
11125
}
11126

11127
int ObPLResolver::resolve_dblink_type_with_synonym(const uint64_t pkg_syn_id,
11128
                                                   const ObString &type_name,
11129
                                                   ObPLCompileUnitAST &func,
11130
                                                   ObPLDataType &pl_type)
11131
{
11132
  int ret = OB_SUCCESS;
11133
#ifdef OB_BUILD_ORACLE_PL
11134
  ObString dblink_name;
11135
  ObString db_name;
11136
  ObString pkg_name;
11137
  ObSchemaChecker checker;
11138
  OZ (checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
11139
  OZ (ObPLDblinkUtil::separate_name_from_synonym(checker, resolve_ctx_.allocator_,
11140
                                                 resolve_ctx_.session_info_.get_effective_tenant_id(),
11141
                                                 resolve_ctx_.session_info_.get_database_name(),
11142
                                                 pkg_syn_id, dblink_name, db_name, pkg_name));
11143
  OZ (resolve_dblink_type(dblink_name, db_name, pkg_name, type_name, func, pl_type));
11144
#endif
11145
  return ret;
11146
}
11147

11148
int ObPLResolver::resolve_dblink_type(const ObString &dblink_name,
11149
                                      const ObString &db_name,
11150
                                      const ObString &pkg_name,
11151
                                      const ObString &udt_name,
11152
                                      ObPLCompileUnitAST &func,
11153
                                      ObPLDataType &pl_type)
11154
{
11155
  int ret = OB_SUCCESS;
11156
  const ObUserDefinedType *udt = NULL;
11157
  OZ (resolve_ctx_.package_guard_.dblink_guard_.get_dblink_type_with_synonym(resolve_ctx_.session_info_,
11158
        resolve_ctx_.schema_guard_, dblink_name, db_name, pkg_name, udt_name, udt));
11159
  OZ (current_block_->get_namespace().get_type_table()->add_external_type(udt));
11160
  OX (func.set_can_cached(false));
11161
  if (OB_SUCC(ret) && udt->is_collection_type()) {
11162
    const ObCollectionType *coll_type = static_cast<const ObCollectionType *>(udt);
11163
    if (OB_NOT_NULL(coll_type) && coll_type->get_element_type().is_record_type()) {
11164
      const ObUserDefinedType *udt2 = NULL;
11165
      uint64_t user_type_id = coll_type->get_element_type().get_user_type_id();
11166
      OZ (resolve_ctx_.package_guard_.dblink_guard_.get_dblink_type_by_id(
11167
                                        extract_package_id(user_type_id), user_type_id, udt2));
11168
      OZ (current_block_->get_namespace().get_type_table()->add_external_type(udt2));
11169
    }
11170
  }
11171
  if (OB_SUCC(ret) && OB_NOT_NULL(udt)) {
11172
    pl_type.set_user_type_id(udt->get_type(), udt->get_user_type_id());
11173
    pl_type.set_type_from(PL_TYPE_PACKAGE);
11174
    pl_type.set_type_from_orgin(PL_TYPE_PACKAGE);
11175
  }
11176
  return ret;
11177
}
11178

11179

11180
int ObPLResolver::resolve_qualified_identifier(ObQualifiedName &q_name,
11181
                                               ObIArray<ObQualifiedName> &columns,
11182
                                               ObIArray<ObRawExpr*> &real_exprs,
11183
                                               ObPLCompileUnitAST &unit_ast,
11184
                                               ObRawExpr *&expr)
11185
{
11186
  int ret = OB_SUCCESS;
11187
  OZ (resolve_qualified_name(q_name, columns, real_exprs, unit_ast, expr));
11188
  //因为obj access的参数拉平处理，a(b,c)在columns会被存储为b,c,a，所以解释完一个ObQualifiedName，
11189
  //都要把他前面的ObQualifiedName拿过来尝试替换一遍参数
11190
  for (int64_t i = 0; OB_SUCC(ret) && i < real_exprs.count(); ++i) {
11191
    OZ (ObRawExprUtils::replace_ref_column(expr, columns.at(i).ref_expr_, real_exprs.at(i)));
11192
  }
11193
  for (int64_t i = 0; OB_SUCC(ret) && i < columns.count(); ++i) {
11194
    OZ (columns.at(i).replace_access_ident_params(q_name.ref_expr_, expr));
11195
  }
11196
  CK (OB_NOT_NULL(expr));
11197
  OZ (formalize_expr(*expr));
11198
  return ret;
11199
}
11200

11201
int ObPLResolver::resolve_sqlcode_or_sqlerrm(ObQualifiedName &q_name,
11202
                                             ObPLCompileUnitAST &unit_ast,
11203
                                             ObRawExpr *&expr)
11204
{
11205
  // 走到这里说明一定是无参的SQLCODE或者SQLERRM，带参数的SQLERRM已经在is_sysfunc处理过了
11206
  int ret = OB_SUCCESS;
11207
  UNUSED(unit_ast);
11208
  if (1 == q_name.access_idents_.count()
11209
      && q_name.access_idents_.at(0).get_type() == AccessNameType::UNKNOWN
11210
      && (0 == q_name.access_idents_.at(0).access_name_.case_compare("SQLCODE")
11211
          || 0 == q_name.access_idents_.at(0).access_name_.case_compare("SQLERRM"))) {
11212
    ObPLSQLCodeSQLErrmRawExpr *c_expr = NULL;
11213
    OZ (expr_factory_.create_raw_expr(T_FUN_PL_SQLCODE_SQLERRM, c_expr));
11214
    CK (OB_NOT_NULL(c_expr));
11215
    OX (c_expr->set_is_sqlcode(0 == q_name.access_idents_.at(0).access_name_.case_compare("SQLCODE")));
11216
    OZ (c_expr->extract_info());
11217
    OX (expr = c_expr);
11218
  } else {
11219
    ret = OB_ERR_SP_UNDECLARED_VAR;
11220
    LOG_WARN("failed to resolve sqlcode or sqlerrm", K(ret), K(q_name));
11221
  }
11222
  return ret;
11223
}
11224

11225
int ObPLResolver::resolve_construct(const ObQualifiedName &q_name,
11226
                                    const ObUDFInfo &udf_info,
11227
                                    const ObUserDefinedType &user_type,
11228
                                    ObRawExpr *&expr)
11229
{
11230
  int ret = OB_SUCCESS;
11231
  if (user_type.is_nested_table_type() || user_type.is_varray_type()) {
11232
    OZ (resolve_collection_construct(q_name, udf_info, &user_type, expr));
11233
  } else if (user_type.is_object_type() && user_type.is_udt_type()) {
11234
    OZ (resolve_object_construct(q_name, udf_info, &user_type, expr));
11235
  } else {
11236
    ret = OB_NOT_SUPPORTED;
11237
    LOG_WARN("only allow collection construct and user define record construct", K(ret), K(user_type));
11238
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "Constructs other than collection constructs and user-defined record constructs");
11239
  }
11240
  return ret;
11241
}
11242

11243
int ObPLResolver::resolve_construct(const ObQualifiedName &q_name,
11244
                                   const ObUDFInfo &udf_info,
11245
                                   ObRawExpr *&expr)
11246
{
11247
  int ret = OB_SUCCESS;
11248
  const ObUserDefinedType *user_type = NULL;
11249
  CK (OB_NOT_NULL(current_block_));
11250
  ObString package_name
11251
    = udf_info.is_udf_udt_cons()
11252
      ? ObString("")
11253
        : udf_info.udf_package_ != udf_info.udf_name_ ? udf_info.udf_package_ : ObString(""); 
11254
  OZ (current_block_->get_namespace().get_pl_data_type_by_name(
11255
                      resolve_ctx_, udf_info.udf_database_, package_name,
11256
                      udf_info.udf_name_, user_type));
11257
  CK (OB_NOT_NULL(user_type));
11258
  // reset the error code, we have to try udf.
11259
  if (OB_FAIL(ret)) {
11260
    LOG_WARN("failed to get type", K(ret), K(package_name), K(udf_info), K(q_name));
11261
    ret = OB_ERR_SP_UNDECLARED_TYPE;
11262
  }
11263
  if (OB_SUCC(ret)) {
11264
    if (user_type->is_nested_table_type()
11265
        || user_type->is_varray_type()) {
11266
      OZ (resolve_collection_construct(q_name, udf_info, user_type, expr));
11267
    } else if (user_type->is_object_type() && user_type->is_udt_type()) {
11268
      OZ (resolve_object_construct(q_name, udf_info, user_type, expr));
11269
    } else {
11270
      ret = OB_NOT_SUPPORTED;
11271
      LOG_WARN("only allow collection construct and user define record construct", K(ret), KPC(user_type));
11272
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "Constructs other than collection constructs and user-defined record constructs");
11273
    }
11274
  }
11275
  return ret;
11276
}
11277

11278
int ObPLResolver::resolve_object_construct(const sql::ObQualifiedName &q_name,
11279
                                           const sql::ObUDFInfo &udf_info,
11280
                                           const ObUserDefinedType *user_type,
11281
                                           ObRawExpr *&expr)
11282
{
11283
  int ret = OB_SUCCESS;
11284
  uint64_t type_id = OB_INVALID_ID;
11285
  OX (type_id = user_type->get_user_type_id());
11286
  if (OB_SUCC(ret)) {
11287
    ObUDFInfo &uinfo = const_cast<ObUDFInfo &>(udf_info);
11288
    if (uinfo.udf_package_.empty()) {
11289
      // object type name should same as constructor name
11290
      uinfo.udf_package_ = uinfo.udf_name_;
11291
    } else if (0 != uinfo.udf_package_.case_compare(uinfo.udf_name_)) {
11292
      if (0 == uinfo.udf_package_.case_compare(OB_ORA_SYS_SCHEMA_NAME)
11293
          && lib::is_oracle_mode()) { // oracle sys udt
11294
        // do nothing
11295
      } else {
11296
        ret = OB_ERR_UNEXPECTED;
11297
        LOG_WARN("type name is not same as constructor name", K(uinfo), K(ret));
11298
      }
11299
    } else {
11300
      // do nothing
11301
    }
11302
    if (OB_SUCC(ret) && OB_NOT_NULL(uinfo.ref_expr_) && uinfo.ref_expr_->get_udf_id() == OB_INVALID_ID) {
11303
      SMART_VAR(ObPLFunctionAST, dummy_ast, resolve_ctx_.allocator_) {
11304
        ObSEArray<ObObjAccessIdx, 1> access_idxs;
11305
        OZ (resolve_udf_info(uinfo, access_idxs, dummy_ast));
11306
      }
11307
    }
11308
    //
11309
    // check is use default constructor
11310
    // for example: object(a number,  constructor object(a varchar));
11311
    // begin v object := object(4); resolve_udf will pick the user defined cons,
11312
    // actually, here we need to use the default construtor, that is: reolsve record construct
11313
    // on the other side: object(a number, constructor(a number) constructor object(a varchar));
11314
    // resolve_udf will pick the right one, we dont need to resolve record_construct.
11315

11316
    bool use_buildin_default_constructor = false;
11317
    if (OB_SUCC(ret)
11318
        && !uinfo.is_udt_overload_default_cons()
11319
        && !user_type->is_opaque_type()) { // opaque type has no member, do not check
11320
      const ObRecordType *object_type = NULL;
11321
      CK (OB_NOT_NULL(object_type = dynamic_cast<const ObRecordType *>(user_type)));
11322

11323
      // must have same attribute and param, exclude self param
11324
      if (udf_info.ref_expr_->get_param_exprs().count() - 1 == object_type->get_member_count()) {
11325
        use_buildin_default_constructor = true;
11326

11327
        for (int64_t i = 1; OB_SUCC(ret) && i < udf_info.ref_expr_->get_param_exprs().count(); ++i) {
11328
          const ObRawExpr *param_expr = udf_info.ref_expr_->get_param_exprs().at(i);
11329
          if (OB_ISNULL(param_expr)) {
11330
            ret = OB_ERR_UNEXPECTED;
11331
            LOG_WARN("null param expr", K(ret));
11332
          } else {
11333
            const ObExprResType &param_res_type = param_expr->get_result_type();
11334
            const ObPLDataType *pl_type = object_type->get_record_member_type(i - 1);
11335
            if (OB_NOT_NULL(pl_type)
11336
                && OB_NOT_NULL(pl_type->get_meta_type())
11337
                && (param_res_type.get_type() == pl_type->get_meta_type()->get_type())) {
11338
                // do nothing
11339
            } else {
11340
              use_buildin_default_constructor = false;
11341
              break;
11342
            }
11343
          }
11344
        }
11345
      }
11346
    }
11347
    OX (expr = udf_info.ref_expr_);
11348
    // if cant find user define construtor, try default construct
11349
    if ((OB_SUCCESS == ret && use_buildin_default_constructor)
11350
     || OB_ERR_SP_WRONG_ARG_NUM == ret
11351
     || OB_ERR_FUNCTION_UNKNOWN == ret
11352
     || OB_ERR_SP_UNDECLARED_VAR == ret
11353
     || OB_ERR_INVALID_TYPE_FOR_OP == ret
11354
     || OB_ERR_PACKAGE_DOSE_NOT_EXIST == ret
11355
     || OB_ERR_SP_DOES_NOT_EXIST == ret) {
11356
      ret = OB_SUCCESS;
11357
      pl_reset_warning_buffer();
11358
      OZ (resolve_record_construct(q_name, udf_info, user_type, expr));
11359
    }
11360
  }
11361
  return ret;
11362
}
11363

11364
int ObPLResolver::resolve_record_construct(const ObQualifiedName &q_name,
11365
                                           const ObUDFInfo &udf_info,
11366
                                           const ObUserDefinedType *user_type,
11367
                                           ObRawExpr *&expr)
11368
{
11369
  int ret = OB_SUCCESS;
11370
  const ObRecordType *object_type = NULL;
11371
  ObObjectConstructRawExpr *object_expr = NULL;
11372
  ObExprResType res_type;
11373
  int64_t rowsize = 0;
11374
  const ObUDTTypeInfo *udt_info = NULL;
11375
  uint64_t tenant_id = OB_INVALID_ID;
11376
  bool is_udt_type = false;
11377
  CK (OB_NOT_NULL(user_type));
11378
  OX (is_udt_type = user_type->is_udt_type());
11379
  CK (OB_NOT_NULL(udf_info.ref_expr_));
11380
  CK (OB_NOT_NULL(object_type = static_cast<const ObRecordType *>(user_type)));
11381
  if (OB_SUCC(ret) && udf_info.param_names_.count() > 0) { // 构造函数暂时不允许使用=>赋值
11382
    ret = OB_ERR_CALL_WRONG_ARG;
11383
    LOG_WARN("PLS-00306: wrong number or types of arguments in call procedure", K(ret));
11384
  }
11385
  if (OB_SUCC(ret)) {
11386
    int64_t param_cnt = udf_info.ref_expr_->get_param_exprs().count();
11387
    int64_t member_cnt = object_type->get_member_count();
11388
    bool is_opaque_cons_and_no_self_param
11389
      = object_type->is_opaque_type() && (param_cnt - 2) == member_cnt && udf_info.is_udf_udt_cons();
11390

11391
    if (OB_SUCC(ret)
11392
        && ((!udf_info.is_udf_udt_cons() && param_cnt != member_cnt)
11393
              || (udf_info.is_udf_udt_cons() && param_cnt - 1 != member_cnt))
11394
        && !is_opaque_cons_and_no_self_param) {
11395
      ret = OB_ERR_CALL_WRONG_ARG;
11396
      LOG_WARN("PLS-00306: wrong number or types of arguments in call",
11397
              K(ret),
11398
              K(q_name),
11399
              K(udf_info.ref_expr_->get_param_exprs().count()),
11400
              K(object_type->get_member_count()));
11401
    }
11402
  }
11403
  OZ (expr_factory_.create_raw_expr(T_FUN_PL_OBJECT_CONSTRUCT, object_expr));
11404
  CK (OB_NOT_NULL(object_expr));
11405
  OZ (user_type->get_size(current_block_->get_namespace(), pl::PL_TYPE_ROW_SIZE, rowsize));
11406
  OX (object_expr->set_rowsize(rowsize));
11407
  OX (res_type.set_type(ObExtendType));
11408
  OX (res_type.set_extend_type(PL_RECORD_TYPE));
11409
  OX (res_type.set_udt_id(user_type->get_user_type_id()));
11410
  OX (object_expr->set_udt_id(user_type->get_user_type_id()));
11411
  OX (object_expr->set_result_type(res_type));
11412
  if (is_udt_type) {
11413
    OX (tenant_id = get_tenant_id_by_object_id(user_type->get_user_type_id()));
11414
    OZ (resolve_ctx_.schema_guard_.get_udt_info(
11415
        tenant_id, user_type->get_user_type_id(), udt_info));
11416
    CK (OB_NOT_NULL(udt_info));
11417
    OX (object_expr->set_database_id(udt_info->get_database_id()));
11418
    OX (object_expr->set_coll_schema_version(udt_info->get_schema_version()));
11419
  }
11420
  for (int64_t i = 0; OB_SUCC(ret) && i < object_type->get_member_count(); ++i) {
11421
    const ObPLDataType *pl_type = object_type->get_record_member_type(i);
11422
    ObExprResType elem_type;
11423
    const ObDataType *data_type = NULL;
11424
    CK (OB_NOT_NULL(pl_type));
11425
    if (OB_FAIL(ret)) {
11426
    } else if (!pl_type->is_obj_type()) {
11427
      OX (elem_type.set_ext());
11428
      OX (elem_type.set_extend_type(pl_type->get_type()));
11429
      OX (elem_type.set_udt_id(pl_type->get_user_type_id()));
11430
    } else {
11431
      CK (OB_NOT_NULL(data_type = pl_type->get_data_type()));
11432
      OX (elem_type.set_meta(data_type->get_meta_type()));
11433
      OX (elem_type.set_accuracy(data_type->get_accuracy()));
11434
    }
11435
    OX (object_expr->add_elem_type(elem_type));
11436
  }
11437
  OZ (object_expr->set_access_names(q_name.access_idents_));
11438
  OX (object_expr->set_func_name(object_type->get_name()));
11439
  int64_t i = udf_info.is_udf_udt_cons() && udf_info.is_contain_self_param_ ? 1 : 0; // ignore the self param
11440
  for (; OB_SUCC(ret) && i < udf_info.ref_expr_->get_param_exprs().count(); ++i) {
11441
    OZ (object_expr->add_param_expr(udf_info.ref_expr_->get_param_exprs().at(i)));
11442
  }
11443
  OX (expr = object_expr);
11444
  return ret;
11445
}
11446

11447
int ObPLResolver::resolve_collection_construct(const ObQualifiedName &q_name,
11448
                                               const ObUDFInfo &udf_info,
11449
                                               const ObUserDefinedType *user_type,
11450
                                               ObRawExpr *&expr)
11451
{
11452
  int ret = OB_SUCCESS;
11453
#ifdef OB_BUILD_ORACLE_PL
11454
  const ObCollectionType *coll_type = NULL;
11455
  ObCollectionConstructRawExpr *coll_expr = NULL;
11456
  ObExprResType res_type;
11457
  const ObUDTTypeInfo *udt_info = NULL;
11458
  uint64_t tenant_id = OB_INVALID_ID;
11459
  bool is_udt_type = false;
11460
  CK (OB_NOT_NULL(user_type));
11461
  OX (is_udt_type = user_type->is_udt_type());
11462
  OZ (expr_factory_.create_raw_expr(T_FUN_PL_COLLECTION_CONSTRUCT, coll_expr));
11463
  CK (OB_NOT_NULL(coll_expr));
11464
  if (OB_SUCC(ret) && udf_info.param_names_.count() > 0) { // 构造函数不允许使用=>赋值
11465
    ret = OB_ERR_CALL_WRONG_ARG;
11466
    LOG_WARN("PLS-00306: wrong number or types of arguments in call to", K(ret));
11467
  }
11468
  CK (OB_NOT_NULL(coll_type = static_cast<const ObCollectionType *>(user_type)));
11469
  OX (coll_expr->set_type(user_type->get_type()));
11470
  OX (coll_expr->set_capacity(user_type->is_varray_type() ? static_cast<const ObVArrayType*>(user_type)->get_capacity() : OB_INVALID_SIZE));
11471
  OX (coll_expr->set_udt_id(user_type->get_user_type_id()));
11472
  OX (coll_expr->set_elem_type(coll_type->get_element_type()));
11473
  OZ (coll_expr->set_access_names(q_name.access_idents_));
11474
  OX (coll_expr->set_func_name(coll_type->get_name()));
11475
  if (is_udt_type) {
11476
    OX (tenant_id = get_tenant_id_by_object_id(user_type->get_user_type_id()));
11477
    OZ (resolve_ctx_.schema_guard_.get_udt_info(
11478
        tenant_id, user_type->get_user_type_id(), udt_info));
11479
    CK (OB_NOT_NULL(udt_info));
11480
    OX (coll_expr->set_database_id(udt_info->get_database_id()));
11481
    OX (coll_expr->set_coll_schema_version(udt_info->get_schema_version()));
11482
  }
11483
  OX (res_type.set_type(ObExtendType));
11484
  OX (res_type.set_extend_type(user_type->get_type()));
11485
  OX (res_type.set_udt_id(user_type->get_user_type_id()));
11486
  OX (coll_expr->set_result_type(res_type));
11487
  CK (OB_NOT_NULL(udf_info.ref_expr_));
11488
  for (int64_t i = 0; OB_SUCC(ret) && i < udf_info.ref_expr_->get_param_exprs().count(); ++i) {
11489
    ObRawExpr *child = udf_info.ref_expr_->get_param_exprs().at(i);
11490
    if (coll_type->get_element_type().is_obj_type()) {
11491
      const ObDataType *data_type = coll_type->get_element_type().get_data_type();
11492
      CK (OB_NOT_NULL(data_type));
11493
      OZ (ObRawExprUtils::build_column_conv_expr(&resolve_ctx_.session_info_,
11494
                                                 expr_factory_,
11495
                                                 data_type->get_obj_type(),
11496
                                                 data_type->get_collation_type(),
11497
                                                 data_type->get_accuracy_value(),
11498
                                                 true,
11499
                                                 NULL,
11500
                                                 NULL,
11501
                                                 child,
11502
                                                 true));
11503
      OZ (coll_expr->add_param_expr(child));
11504
    } else {
11505
      bool is_legal = true;
11506
      uint64_t actual_udt_id = OB_INVALID_ID;
11507
      if (child->get_result_type().is_null()) {
11508
      } else if (child->get_result_type().is_ext()) {
11509
        if (child->is_obj_access_expr()) {
11510
          ObPLDataType actually_type;
11511
          const ObObjAccessRawExpr *obj_access = NULL;
11512
          CK (OB_NOT_NULL(obj_access = static_cast<const ObObjAccessRawExpr*>(child)));
11513
          OZ (obj_access->get_final_type(actually_type));
11514
          OX (actual_udt_id = actually_type.get_user_type_id());
11515
        } else {
11516
          actual_udt_id = child->get_result_type().get_udt_id();
11517
        }
11518
        if (actual_udt_id != coll_type->get_element_type().get_user_type_id()) {
11519
          OZ (check_composite_compatible(current_block_->get_namespace(),
11520
                                          actual_udt_id,
11521
                                          coll_type->get_element_type().get_user_type_id(),
11522
                                          is_legal));
11523
        }
11524
      } else {
11525
        is_legal = false;
11526
      }
11527
      if (OB_FAIL(ret)) {
11528
      } else if (!is_legal) {
11529
        ret = OB_ERR_CALL_WRONG_ARG;
11530
        LOG_WARN("PLS-00306: wrong number or types of arguments in call stmt",
11531
                K(ret), K(actual_udt_id), K(coll_type->get_element_type()));
11532
      } else {
11533
        OZ (coll_expr->add_param_expr(child));
11534
      }
11535
    }
11536
  }
11537
  OX (expr = coll_expr);
11538
#else
11539
  UNUSEDx(q_name, udf_info, user_type, expr);
11540
#endif
11541
  return ret;
11542
}
11543

11544
int ObPLResolver::resolve_udf_without_brackets(
11545
  ObQualifiedName &q_name, ObPLCompileUnitAST &unit_ast, ObRawExpr *&expr)
11546
{
11547
  int ret = OB_SUCCESS;
11548
  ObUDFRawExpr *udf_expr = NULL;
11549
  ObObjAccessIdent &access_ident = q_name.access_idents_.at(q_name.access_idents_.count() - 1);
11550
  ObUDFInfo &udf_info = access_ident.udf_info_;
11551
  ObSEArray<ObObjAccessIdx, 4> access_idxs;
11552
  OX (access_ident.set_pl_udf());
11553
  OZ (expr_factory_.create_raw_expr(T_FUN_UDF, udf_expr), K(q_name));
11554
  CK (OB_NOT_NULL(udf_expr));
11555
  OX (udf_expr->set_func_name(access_ident.access_name_));
11556
  OX (udf_info.ref_expr_ = udf_expr);
11557
  OX (udf_info.udf_name_ = access_ident.access_name_);
11558
  OZ (resolve_name(q_name, current_block_->get_namespace(), expr_factory_, &resolve_ctx_.session_info_, access_idxs, unit_ast),
11559
    K(access_idxs), K(q_name));
11560
  OV (access_idxs.at(access_idxs.count() - 1).is_udf_type());
11561
  OX (expr = access_idxs.at(access_idxs.count() - 1).get_sysfunc_);
11562
  CK (OB_NOT_NULL(expr));
11563
  if ((OB_FAIL(ret) && ret != OB_ERR_INSUFFICIENT_PRIVILEGE)
11564
      || (OB_NOT_NULL(expr) && T_FUN_PL_COLLECTION_CONSTRUCT == expr->get_expr_type())
11565
      || (OB_NOT_NULL(expr) && T_FUN_PL_OBJECT_CONSTRUCT == expr->get_expr_type())) {
11566
    ret = OB_ERR_SP_UNDECLARED_VAR;
11567
  }
11568
  return ret;
11569
}
11570

11571
int ObPLResolver::replace_udf_param_expr(
11572
  ObQualifiedName &q_name, ObIArray<ObQualifiedName> &columns, ObIArray<ObRawExpr*> &real_exprs)
11573
{
11574
  int ret = OB_SUCCESS;
11575
  for (int64_t i = 0; OB_SUCC(ret) && i < q_name.access_idents_.count(); ++i) {
11576
    ObObjAccessIdent &access_ident = q_name.access_idents_.at(i);
11577
    if (access_ident.is_pl_udf()) {
11578
      OZ (replace_udf_param_expr(access_ident, columns, real_exprs));
11579
    } else if (access_ident.is_sys_func()) {
11580
      // cases like : xmlparse(document expr).getclobval()
11581
      ObRawExpr *expr = static_cast<ObRawExpr *>(access_ident.sys_func_expr_);
11582
      for (int64_t i = 0; OB_SUCC(ret) && i < real_exprs.count(); ++i) {
11583
        if (OB_FAIL(ObRawExprUtils::replace_ref_column(expr, columns.at(i).ref_expr_, real_exprs.at(i)))) {
11584
          LOG_WARN("replace column ref expr failed", K(ret));
11585
        }
11586
      }
11587
    } else { /*do nothing*/ }
11588
  }
11589
  return ret;
11590
}
11591

11592
int ObPLResolver::replace_udf_param_expr(
11593
  ObObjAccessIdent &access_ident, ObIArray<ObQualifiedName> &columns, ObIArray<ObRawExpr*> &real_exprs)
11594
{
11595
  int ret = OB_SUCCESS;
11596
  ObUDFInfo &udf_info = access_ident.udf_info_;
11597
  ObRawExpr *expr = static_cast<ObRawExpr *>(udf_info.ref_expr_);
11598
  if (OB_ISNULL(expr)) {
11599
    ret = OB_ERR_UNEXPECTED;
11600
    LOG_WARN("udf expr is null", K(ret));
11601
  } else {
11602
    //如果是UDF，要先把UDF INFO里的参数替换掉，否则重载匹配的时候会失败
11603
    for (int64_t i = 0; OB_SUCC(ret) && i < real_exprs.count(); ++i) {
11604
      OZ (ObRawExprUtils::replace_ref_column(expr, columns.at(i).ref_expr_, real_exprs.at(i)));
11605
      for (int64_t j = 0; OB_SUCC(ret) && j < udf_info.param_exprs_.count(); ++j) {
11606
        CK (OB_NOT_NULL(udf_info.param_exprs_.at(j)));
11607
        if (OB_FAIL(ret)) {
11608
        } else if (udf_info.param_exprs_.at(j) == columns.at(i).ref_expr_) {
11609
          udf_info.param_exprs_.at(j) = real_exprs.at(i);
11610
        } else if (T_SP_CPARAM == udf_info.param_exprs_.at(j)->get_expr_type()) {
11611
          ObCallParamRawExpr* call_expr =
11612
            static_cast<ObCallParamRawExpr*>(udf_info.param_exprs_.at(j));
11613
          CK (OB_NOT_NULL(call_expr));
11614
          if (OB_SUCC(ret) && call_expr->get_expr() == columns.at(i).ref_expr_) {
11615
            call_expr->set_expr(real_exprs.at(i));
11616
          }
11617
        } else if (udf_info.param_exprs_.at(j)->get_param_count() > 0) {
11618
          OZ (recursive_replace_expr(udf_info.param_exprs_.at(j), columns.at(i), real_exprs.at(i)));
11619
        }
11620
      }
11621
    }
11622
  }
11623
  return ret;
11624
}
11625

11626
int ObPLResolver::resolve_qualified_name(ObQualifiedName &q_name,
11627
                                         ObIArray<ObQualifiedName> &columns,
11628
                                         ObIArray<ObRawExpr*> &real_exprs,
11629
                                         ObPLCompileUnitAST &unit_ast,
11630
                                         ObRawExpr *&expr)
11631
{
11632
  int ret = OB_SUCCESS;
11633

11634
  SET_LOG_CHECK_MODE();
11635
  if (!q_name.dblink_name_.empty()) {
11636
    ret = OB_NOT_SUPPORTED;
11637
    LOG_WARN("dblink sequence and udf not support in PL", K(ret), K(q_name));
11638
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "dblink sequence and udf in PL");
11639
  }
11640
  OZ (replace_udf_param_expr(q_name, columns, real_exprs));
11641
  if (OB_FAIL(ret)) {
11642
  } else if (q_name.is_sys_func()) {
11643
    if (OB_FAIL(q_name.access_idents_.at(0).sys_func_expr_->check_param_num())) {
11644
      LOG_WARN("sys func param number not match", K(ret));
11645
    } else {
11646
      expr = static_cast<ObRawExpr *>(q_name.access_idents_.at(0).sys_func_expr_);
11647
    }
11648
  } else if (q_name.is_pl_udf() || q_name.is_udf_return_access()) {
11649
    /*
11650
     * in pl context, we should consider four types of function:
11651
     * 1  standalone function, which is defined by create function ddl
11652
     * 2  package public function, which is declared in package spec and defined in package body
11653
     * 3  package private function, which is declared and defined in package body
11654
     * 4  system function, which is define by database system ,such as concat
11655
     *
11656
     * in oracle, function resolve precedence in pl is package private function, then sys function,
11657
     * then package public function or standalone function
11658
     *
11659
     * here we use
11660
     * is_udf to represent package private/public and standalone function
11661
     * is sys_func to represent sys function
11662
     * is_external_udf to represent package public and standalone function
11663
     *
11664
     * record dependency info in resolve_routine() function already!
11665
     */
11666

11667
    //try to resolve as udf
11668
    ObObjAccessIdent &access_ident = q_name.access_idents_.at(q_name.access_idents_.count() - 1);
11669
    ObUDFInfo &udf_info = access_ident.udf_info_;
11670
    expr = static_cast<ObRawExpr *>(udf_info.ref_expr_);
11671
    if (OB_ISNULL(expr)) {
11672
      ret = OB_ERR_UNEXPECTED;
11673
      LOG_WARN("udf expr is null", K(ret));
11674
    } else {
11675
      if (OB_SUCC(ret)) {
11676
        if (q_name.is_pl_udf()) {
11677
          ObSEArray<ObObjAccessIdx, 4> access_idxs;
11678
          OZ (resolve_name(q_name, current_block_->get_namespace(), expr_factory_, &resolve_ctx_.session_info_, access_idxs, unit_ast));
11679
          if (OB_FAIL(ret)) {
11680
          } else if (access_idxs.at(access_idxs.count() - 1).is_udf_type()) {
11681
            OX (expr = reinterpret_cast<ObRawExpr*>(access_idxs.at(access_idxs.count() - 1).get_sysfunc_));
11682
          } else {
11683
            OZ (make_var_from_access(access_idxs,
11684
                                     expr_factory_,
11685
                                     &(resolve_ctx_.session_info_),
11686
                                     &(resolve_ctx_.schema_guard_),
11687
                                     current_block_->get_namespace(),
11688
                                     expr));
11689
          }
11690
          CK (OB_NOT_NULL(expr));
11691
        } else { // 如果是udf return access，需要当做var解析
11692
          if (OB_FAIL(resolve_var(q_name, unit_ast, expr))) {
11693
            LOG_WARN("failed to resolve var", K(q_name), K(ret));
11694
          }
11695
        }
11696
      }
11697
    }
11698
  } else {
11699
    if (OB_FAIL(resolve_var(q_name, unit_ast, expr))) {
11700
      if (OB_ERR_SP_UNDECLARED_VAR == ret) {
11701
        pl_reset_warning_buffer();
11702
        if (OB_FAIL(resolve_sequence_object(q_name, unit_ast, expr))) {
11703
          LOG_IN_CHECK_MODE("failed to sequence object", K(q_name), K(ret));
11704
        }
11705
      } else {
11706
        LOG_IN_CHECK_MODE("failed to resolve var", K(q_name), K(ret));
11707
      }
11708
    }
11709
    if (OB_ERR_SP_UNDECLARED_VAR == ret) {
11710
      pl_reset_warning_buffer();
11711
      if (OB_FAIL(resolve_sqlcode_or_sqlerrm(q_name, unit_ast, expr))) {
11712
        LOG_IN_CHECK_MODE("failed to resolve sqlcode or sqlerrm",  K(ret), K(q_name));
11713
      }
11714
    }
11715
    if (OB_ERR_SP_UNDECLARED_VAR == ret) {
11716
      pl_reset_warning_buffer();
11717
      if (OB_FAIL(resolve_udf_without_brackets(q_name, unit_ast, expr))) {
11718
        LOG_IN_CHECK_MODE("failed to resolve udf without bracks", K(ret), K(q_name));
11719
      }
11720
    }
11721
    if (OB_ERR_SP_UNDECLARED_VAR == ret) {
11722
      if ((T_SP_IF == item_type_ || T_SP_CASE == item_type_ || T_SP_WHEN == item_type_)
11723
          && lib::is_oracle_mode()) {
11724
        pl_reset_warning_buffer();
11725
        ret = check_undeclared_var_type(q_name);
11726
      }
11727
      if (OB_ERR_SP_UNDECLARED_VAR == ret) {
11728
        LOG_USER_ERROR(OB_ERR_SP_UNDECLARED_VAR, q_name.col_name_.length(), q_name.col_name_.ptr());
11729
      }
11730
    }
11731
  }
11732
  //in static typing engine, we wont do implict cast at stage of execution,
11733
  //for some expr like ObExprIn/ObExprArgCase, if type of left is not match with right,
11734
  //we rewrite "a in (b,c)" to "a in b or a in c"
11735
  //"case a when b xx when c xx" to "case when a == b then xx case when a == c then xx"
11736
  if (OB_SUCC(ret)) {
11737
    bool transformed = false;
11738
    OZ (formalize_expr(*expr));
11739
    OZ(ObTransformPreProcess::transform_expr(unit_ast.get_expr_factory(),
11740
                                              resolve_ctx_.session_info_, expr,
11741
                                              transformed));
11742
  }
11743

11744
  CANCLE_LOG_CHECK_MODE();
11745
  return ret;
11746
}
11747

11748
int ObPLResolver::resolve_var(ObQualifiedName &q_name, ObPLCompileUnitAST &func, ObRawExpr *&expr,
11749
                              bool for_write)
11750
{
11751
  int ret = OB_SUCCESS;
11752
  if (OB_ISNULL(current_block_)) {
11753
    ret = OB_ERR_UNEXPECTED;
11754
    LOG_WARN("Symbol table is NULL", K(current_block_), K(expr), K(ret));
11755
  } else if (OB_FAIL(resolve_var(q_name, current_block_->get_namespace(), expr_factory_,
11756
                                 &resolve_ctx_.session_info_, func, expr, for_write))) {
11757
    LOG_IN_CHECK_MODE("failed to resolve var", K(q_name), K(expr), K(ret));
11758
  } else { /*do nothing*/ }
11759
  return ret;
11760
}
11761

11762
int ObPLResolver::make_self_symbol_expr(ObPLCompileUnitAST &func, ObRawExpr *&expr)
11763
{
11764
  int ret = OB_SUCCESS;
11765
  ObObjAccessIdent access_ident;
11766
  ObArray<ObObjAccessIdx> access_idxs;
11767
  new (&access_ident) ObObjAccessIdent(ObString("SELF"), OB_INVALID_INDEX);
11768
  OX (expr = NULL);
11769
  CK (OB_NOT_NULL(current_block_));
11770
  OZ (resolve_access_ident(access_ident,
11771
                           current_block_->get_namespace(),
11772
                           expr_factory_,
11773
                           &resolve_ctx_.session_info_,
11774
                           access_idxs,
11775
                           func));
11776
  OZ (make_var_from_access(access_idxs,
11777
                           expr_factory_,
11778
                           &(resolve_ctx_.session_info_),
11779
                           &(resolve_ctx_.schema_guard_),
11780
                           current_block_->get_namespace(),
11781
                           expr));
11782
  CK (OB_NOT_NULL(expr));
11783
  return ret;
11784
}
11785

11786
#ifdef OB_BUILD_ORACLE_PL
11787
int ObPLResolver::add_udt_self_argument(const ObIRoutineInfo *routine_info,
11788
                                        ObIArray<ObRawExpr*> &expr_params,
11789
                                        ObIArray<ObObjAccessIdx> &access_idxs,
11790
                                        ObUDFInfo &udf_info,
11791
                                        ObPLCompileUnitAST &func)
11792
{
11793
  int ret = OB_SUCCESS;
11794
  if (OB_NOT_NULL(routine_info)
11795
      && routine_info->is_udt_routine() // Add Self Argument For UDT Routine.
11796
      && !routine_info->is_udt_static_routine() // Static Routine Has Not Self Argument.
11797
      && expr_params.count() < routine_info->get_param_count()
11798
      && (0 == expr_params.count()
11799
           || (expr_params.count() >= 1
11800
                && !expr_params.at(0)->has_flag(IS_UDT_UDF_SELF_PARAM)
11801
                && !(access_idxs.count() > 0
11802
                      && ObObjAccessIdx::IS_UDT_NS == access_idxs.at(access_idxs.count() - 1).access_type_
11803
                      && expr_params.at(0)->get_result_type().get_expr_udt_id()
11804
                        == access_idxs.at(access_idxs.count() - 1).var_index_)))) {
11805
    ObRawExpr *self_argument = NULL;
11806
    CK (OB_NOT_NULL(udf_info.ref_expr_));
11807
    if (OB_FAIL(ret)) {
11808
    } else if (routine_info->is_udt_cons()) { // UDT Construct Self Argument.
11809
      OZ (ObPLUDTObjectManager::make_constructor_self_expr(
11810
                                    resolve_ctx_,
11811
                                    udf_info.udf_database_,
11812
                                    udf_info.udf_name_,
11813
                                    resolve_ctx_.session_info_.get_effective_tenant_id(),
11814
                                    expr_factory_,
11815
                                    current_block_->get_namespace(),
11816
                                    self_argument));
11817
      CK (OB_NOT_NULL(self_argument));
11818
      OZ (self_argument->formalize(&resolve_ctx_.session_info_));
11819
      OX (udf_info.set_is_udf_udt_cons());
11820
      OZ (func.add_expr(self_argument));
11821
    } else if (access_idxs.count() > 0) { // Member Self Argument With Prefix.
11822
      if (access_idxs.at(access_idxs.count() - 1).is_udf_type()) {
11823
        OX (self_argument = access_idxs.at(access_idxs.count() - 1).get_sysfunc_);
11824
        OX (access_idxs.reset());
11825
      } else {
11826
        OZ (make_var_from_access(access_idxs,
11827
                                 expr_factory_,
11828
                                 &(resolve_ctx_.session_info_),
11829
                                 &resolve_ctx_.schema_guard_,
11830
                                 current_block_->get_namespace(),
11831
                                 self_argument));
11832
        if (OB_SUCC(ret) && !ObObjAccessIdx::is_expr_type(access_idxs)) {
11833
          bool for_write = false;
11834
          ObIRoutineParam *param = nullptr;
11835
          OZ (routine_info->get_routine_param(0, param));
11836
          CK (OB_NOT_NULL(param));
11837
          OX (for_write = !param->is_in_param());
11838
          OZ (check_variable_accessible(self_argument, for_write));
11839
        }
11840
        OX (access_idxs.reset()); // Erase Pre Access. Start New Begin with UDF.
11841
      }
11842
    } else { // Member Self Argument Without Prefix.
11843
      OZ (make_self_symbol_expr(func, self_argument));
11844
    }
11845
    CK (OB_NOT_NULL(self_argument));
11846
    OZ (self_argument->add_flag(IS_UDT_UDF_SELF_PARAM));
11847
    if (OB_SUCC(ret) && self_argument->is_obj_access_expr()) {
11848
      OZ (func.add_obj_access_expr(self_argument));
11849
    }
11850
    OZ (udf_info.ref_expr_->add_param_expr(self_argument));
11851
    OX (udf_info.udf_param_num_++);
11852
    OZ (expr_params.push_back(self_argument));
11853
    for(int64_t i = udf_info.ref_expr_->get_children_count() - 1; OB_SUCC(ret) && i > 0; --i) {
11854
      OZ (udf_info.ref_expr_->replace_param_expr(i, expr_params.at(i - 1)));
11855
    }
11856
    OZ (udf_info.ref_expr_->replace_param_expr(0, self_argument));
11857
    OX (udf_info.is_contain_self_param_ = true);
11858
  }
11859
  return ret;
11860
}
11861
#endif
11862

11863
int ObPLResolver::resolve_udf_info(
11864
  ObUDFInfo &udf_info, ObIArray<ObObjAccessIdx> &access_idxs, ObPLCompileUnitAST &func)
11865
{
11866
  int ret = OB_SUCCESS;
11867
  ObString db_name = udf_info.udf_database_;
11868
  ObString package_name = udf_info.udf_package_;
11869
  ObString udf_name = udf_info.udf_name_;
11870
  ObSchemaChecker schema_checker;
11871
  const ObIRoutineInfo *routine_info = NULL;
11872
  ObProcType routine_type = STANDALONE_FUNCTION;
11873
  ObSEArray<ObRawExpr*, 4> expr_params;
11874

11875
  CK (OB_NOT_NULL(udf_info.ref_expr_));
11876
  CK (OB_NOT_NULL(current_block_));
11877
  OX (func.set_external_state());
11878
  OZ (schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
11879
  OZ (ObRawExprUtils::rebuild_expr_params(udf_info, &expr_factory_, expr_params), K(udf_info), K(access_idxs));
11880
  {
11881
    ObPLMockSelfArg self(access_idxs, expr_params, expr_factory_, resolve_ctx_.session_info_);;
11882
    OZ (self.mock());
11883
    OZ (current_block_->get_namespace().resolve_routine(resolve_ctx_,
11884
                                                        udf_info.udf_database_,
11885
                                                        udf_info.udf_package_,
11886
                                                        udf_info.udf_name_,
11887
                                                        expr_params,
11888
                                                        routine_type,
11889
                                                        routine_info), K(udf_info));
11890
  }
11891

11892
  if (OB_SUCC(ret) && OB_NOT_NULL(routine_info)) {
11893
    if ((routine_info->is_reads_sql_data() && func.get_compile_flag().compile_with_rnds())
11894
        || (routine_info->is_modifies_sql_data() && func.get_compile_flag().compile_with_wnds())) {
11895
      ret = OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA;
11896
      LOG_WARN("PLS-00452: Subprogram 'string' violates its associated pragma", K(ret), K(func.get_compile_flag()), K(func.get_compile_flag()));
11897
      LOG_USER_ERROR(OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA, func.get_name().length(), func.get_name().ptr());
11898
    }
11899
  }
11900

11901
#ifdef OB_BUILD_ORACLE_PL
11902
  OZ (add_udt_self_argument(routine_info, expr_params, access_idxs, udf_info, func),
11903
    K(access_idxs), K(expr_params));
11904
#endif
11905

11906
  // adjust routine database name, will set to ObUDFRawExpr later.
11907
  if (OB_SUCC(ret)
11908
      && db_name.empty()
11909
      && OB_NOT_NULL(routine_info)
11910
      && routine_info->get_database_id() != OB_INVALID_ID) {
11911
    if (OB_SYS_DATABASE_ID == routine_info->get_database_id()) {
11912
      db_name = OB_SYS_DATABASE_NAME;
11913
    } else {
11914
      // may be synonym, we should process public synonym in here, do not add db prefix for public synonym.
11915
      ObString &synonym_name = udf_info.udf_package_.empty() ? udf_info.udf_name_ : udf_info.udf_package_;
11916
      ObString object_name;
11917
      uint64_t object_database_id = OB_INVALID_ID;
11918
      uint64_t synonym_id = OB_INVALID_ID;
11919
      bool exist = false;
11920
      bool is_public = false;
11921
      OZ (schema_checker.get_synonym_schema(resolve_ctx_.session_info_.get_effective_tenant_id(),
11922
                                            resolve_ctx_.session_info_.get_database_id(),
11923
                                            synonym_name,
11924
                                            object_database_id, synonym_id, object_name, exist,
11925
                                            true, // need search public synonym
11926
                                            &is_public));
11927
      if (OB_FAIL(ret) || !exist) {
11928
        ret = OB_SUCCESS; // some case may not be synonym.
11929
      } else if (!is_public) {
11930
        if (routine_info->get_database_id() != resolve_ctx_.session_info_.get_database_id()) {
11931
          db_name = resolve_ctx_.session_info_.get_database_name();
11932
        }
11933
      } else {
11934
        db_name = OB_SYS_DATABASE_NAME;
11935
      }
11936
    }
11937
  }
11938

11939
  if (OB_SUCC(ret)) {
11940
    if (PACKAGE_PROCEDURE == routine_type
11941
        || PACKAGE_FUNCTION == routine_type
11942
        || UDT_PROCEDURE == routine_type
11943
        || UDT_FUNCTION == routine_type) {
11944

11945
      const ObPLRoutineInfo *package_routine_info = static_cast<const ObPLRoutineInfo *>(routine_info);
11946

11947
      CK (OB_NOT_NULL(package_routine_info));
11948

11949
      OZ (check_package_accessible(
11950
        current_block_, resolve_ctx_.schema_guard_, *package_routine_info));
11951

11952
      if (OB_SUCC(ret)
11953
          && (ObPLBlockNS::BLOCK_PACKAGE_SPEC == current_block_->get_namespace().get_block_type()
11954
              || ObPLBlockNS::BLOCK_OBJECT_SPEC == current_block_->get_namespace().get_block_type())
11955
          && package_routine_info->get_pkg_id() == current_block_->get_namespace().get_package_id()) {
11956
        ret = OB_ERR_REFER_SAME_PACKAGE;
11957
        LOG_WARN("variable or constant initialization may not refer to functions"
11958
                 "declared in the same package",
11959
                 K(ret), KPC(package_routine_info));
11960
      }
11961

11962
      if (OB_SUCC(ret)
11963
          && resolve_ctx_.is_sql_scope_
11964
          && package_routine_info->is_private_routine()) {
11965
        ret = OB_ERR_PRIVATE_UDF_USE_IN_SQL;
11966
        LOG_WARN("function 'string' may not be used in SQL", K(ret), K(udf_name));
11967
        LOG_USER_ERROR(OB_ERR_PRIVATE_UDF_USE_IN_SQL, udf_name.length(), udf_name.ptr());
11968
      }
11969

11970
#ifdef OB_BUILD_ORACLE_PL
11971
      if (OB_SUCC(ret) && package_routine_info->is_udt_cons()) {
11972
        bool is_overloaded = false;
11973
        const ObUDTTypeInfo *udt_info = NULL;
11974
        const uint64_t tenant_id = package_routine_info->get_tenant_id();
11975
        OZ (resolve_ctx_.schema_guard_.get_udt_info(
11976
          tenant_id, package_routine_info->get_pkg_id(), udt_info));
11977
        CK (OB_NOT_NULL(udt_info));
11978
        OZ (ObPLUDTObjectManager::check_overload_default_cons(package_routine_info,
11979
                                                              udt_info,
11980
                                                              is_overloaded));
11981
        if (is_overloaded) {
11982
          OX (udf_info.set_is_udt_overload_default_cons());
11983
        }
11984
      }
11985
#endif
11986

11987
      OX (package_name = package_name.empty()
11988
          ? current_block_->get_namespace().get_package_name() : package_name);
11989

11990
      bool is_package_body_udf
11991
        = !package_routine_info->is_udt_routine()
11992
          && package_routine_info->get_pkg_id() == current_block_->get_namespace().get_package_id()
11993
          && (ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY == current_block_->get_namespace().get_block_type()
11994
              || ObPLBlockNS::BlockType::BLOCK_OBJECT_BODY == current_block_->get_namespace().get_block_type()
11995
              || ObPLBlockNS::BlockType::BLOCK_ROUTINE == current_block_->get_namespace().get_block_type());
11996
      int64_t cur_pkg_version = current_block_->get_namespace().get_package_version();
11997
      if (OB_SUCC(ret)
11998
          && OB_INVALID_ID != package_routine_info->get_pkg_id()
11999
          && package_routine_info->get_pkg_id() != current_block_->get_namespace().get_package_id()) {
12000
        share::schema::ObSchemaType schema_type = OB_MAX_SCHEMA;
12001
        schema_type = package_routine_info->is_udt_routine() ? UDT_SCHEMA : PACKAGE_SCHEMA;
12002
        OZ (resolve_ctx_.schema_guard_.get_schema_version(schema_type,
12003
                                                          package_routine_info->get_tenant_id(),
12004
                                                          package_routine_info->get_pkg_id(),
12005
                                                          cur_pkg_version));
12006
      }
12007
      OZ (ObRawExprUtils::resolve_udf_common_info(db_name,
12008
                                                  package_name,
12009
                                                  package_routine_info->get_id(),
12010
                                                  package_routine_info->get_pkg_id(),
12011
                                                  package_routine_info->get_subprogram_path(),
12012
                                                  common::OB_INVALID_VERSION, /*udf_schema_version*/
12013
                                                  cur_pkg_version,
12014
                                                  package_routine_info->is_deterministic(),
12015
                                                  package_routine_info->is_parallel_enable(),
12016
                                                  is_package_body_udf,
12017
                                                  false,
12018
                                                  common::OB_INVALID_ID,
12019
                                                  udf_info));
12020
      OZ (ObRawExprUtils::resolve_udf_param_types(package_routine_info,
12021
                                                  resolve_ctx_.schema_guard_,
12022
                                                  resolve_ctx_.session_info_,
12023
                                                  resolve_ctx_.allocator_,
12024
                                                  resolve_ctx_.sql_proxy_,
12025
                                                  udf_info), udf_info);
12026
      OZ (ObRawExprUtils::resolve_udf_param_exprs(package_routine_info,
12027
                                                  current_block_->get_namespace(),
12028
                                                  schema_checker,
12029
                                                  resolve_ctx_.session_info_,
12030
                                                  resolve_ctx_.allocator_,
12031
                                                  resolve_ctx_.is_prepare_protocol_,
12032
                                                  expr_factory_,
12033
                                                  resolve_ctx_.sql_proxy_,
12034
                                                  resolve_ctx_.extern_param_info_,
12035
                                                  udf_info), udf_info);
12036
    } else if (STANDALONE_PROCEDURE == routine_type
12037
               || STANDALONE_FUNCTION == routine_type) {
12038

12039
      const share::schema::ObRoutineInfo *schema_routine_info = static_cast<const ObRoutineInfo *>(routine_info);
12040
      const ObPackageInfo* package_info = NULL;
12041
      const ObUDTTypeInfo *udt_info = NULL;
12042
      int64_t schema_version = OB_INVALID_VERSION;
12043
      uint64_t routine_id = OB_INVALID_ID;
12044

12045
      CK (OB_NOT_NULL(schema_routine_info));
12046

12047
      OZ (check_routine_accessible(
12048
        current_block_, resolve_ctx_.schema_guard_, *schema_routine_info));
12049

12050
      OX (routine_id = (OB_INVALID_ID == schema_routine_info->get_package_id())
12051
          ? schema_routine_info->get_routine_id() : schema_routine_info->get_subprogram_id());
12052

12053
      OX (udf_info.is_udt_udf_ = schema_routine_info->is_udt_routine());
12054

12055
      if (OB_SUCC(ret) && routine_id == schema_routine_info->get_subprogram_id()) {
12056
        if (!udf_info.is_udt_udf_) {
12057
          OZ (resolve_ctx_.schema_guard_.get_package_info(
12058
              schema_routine_info->get_tenant_id(), schema_routine_info->get_package_id(), package_info));
12059
          CK (OB_NOT_NULL(package_info));
12060
          OX (schema_version = package_info->get_schema_version());
12061
        }
12062
#ifdef OB_BUILD_ORACLE_PL
12063
        else {
12064
          OZ (resolve_ctx_.schema_guard_.get_udt_info(
12065
              schema_routine_info->get_tenant_id(), schema_routine_info->get_package_id(), udt_info));
12066
          CK (OB_NOT_NULL(udt_info));
12067
          OX (schema_version = udt_info->get_schema_version());
12068

12069
          // to check is this overload the default constructor
12070
          if (OB_SUCC(ret) && schema_routine_info->is_udt_cons()) {
12071
            bool is_overloaded = false;
12072
            OZ (ObPLUDTObjectManager::check_overload_default_cons(schema_routine_info,
12073
                                                                  udt_info,
12074
                                                                  is_overloaded));
12075
            if (is_overloaded) {
12076
              OX (udf_info.set_is_udt_overload_default_cons());
12077
            }
12078
          }
12079
        }
12080
#endif
12081
      }
12082
      OZ (ObRawExprUtils::resolve_udf_common_info(db_name,
12083
                                                  package_name,
12084
                                                  routine_id,
12085
                                                  schema_routine_info->get_package_id(),
12086
                                                  ObArray<int64_t>(),
12087
                                                  routine_id == schema_routine_info->get_subprogram_id()
12088
                                                    ? common::OB_INVALID_VERSION
12089
                                                      : schema_routine_info->get_schema_version(),
12090
                                                  routine_id == schema_routine_info->get_subprogram_id()
12091
                                                    ? schema_version
12092
                                                      : common::OB_INVALID_VERSION, /*pkg_schema_version*/
12093
                                                  schema_routine_info->is_deterministic(),
12094
                                                  schema_routine_info->is_parallel_enable(),
12095
                                                  false, /*is_pkg_body_udf*/
12096
                                                  schema_routine_info->is_aggregate(),
12097
                                                  schema_routine_info->get_type_id(),
12098
                                                  udf_info));
12099
      OZ (ObRawExprUtils::resolve_udf_param_types(schema_routine_info,
12100
                                                  resolve_ctx_.schema_guard_,
12101
                                                  resolve_ctx_.session_info_,
12102
                                                  resolve_ctx_.allocator_,
12103
                                                  resolve_ctx_.sql_proxy_,
12104
                                                  udf_info), udf_info);
12105
      OZ (ObRawExprUtils::resolve_udf_param_exprs(schema_routine_info,
12106
                                                  current_block_->get_namespace(),
12107
                                                  schema_checker,
12108
                                                  resolve_ctx_.session_info_,
12109
                                                  resolve_ctx_.allocator_,
12110
                                                  resolve_ctx_.is_prepare_protocol_,
12111
                                                  expr_factory_,
12112
                                                  resolve_ctx_.sql_proxy_,
12113
                                                  resolve_ctx_.extern_param_info_,
12114
                                                  udf_info), udf_info);
12115
    } else if (NESTED_PROCEDURE == routine_type || NESTED_FUNCTION == routine_type) {
12116
      const ObPLRoutineInfo *sub_routine_info = static_cast<const ObPLRoutineInfo *>(routine_info);
12117

12118
      CK (OB_NOT_NULL(sub_routine_info));
12119

12120
      OZ (ObRawExprUtils::resolve_udf_common_info(db_name,
12121
                                                  package_name,
12122
                                                  sub_routine_info->get_parent_id(),
12123
                                                  current_block_->get_namespace().get_package_id(),
12124
                                                  sub_routine_info->get_subprogram_path(),
12125
                                                  common::OB_INVALID_VERSION, /*udf_schema_version*/
12126
                                                  common::OB_INVALID_VERSION, /*pkg_schema_version*/
12127
                                                  sub_routine_info->is_deterministic(),
12128
                                                  sub_routine_info->is_parallel_enable(),
12129
                                                  pl::ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY
12130
                                                    == current_block_->get_namespace().get_block_type(),
12131
                                                  false,
12132
                                                  common::OB_INVALID_ID,
12133
                                                  udf_info));
12134
      OZ (ObRawExprUtils::resolve_udf_param_types(sub_routine_info,
12135
                                                  resolve_ctx_.schema_guard_,
12136
                                                  resolve_ctx_.session_info_,
12137
                                                  resolve_ctx_.allocator_,
12138
                                                  resolve_ctx_.sql_proxy_,
12139
                                                  udf_info), udf_info);
12140
      OZ (ObRawExprUtils::resolve_udf_param_exprs(sub_routine_info,
12141
                                                  current_block_->get_namespace(),
12142
                                                  schema_checker,
12143
                                                  resolve_ctx_.session_info_,
12144
                                                  resolve_ctx_.allocator_,
12145
                                                  resolve_ctx_.is_prepare_protocol_,
12146
                                                  expr_factory_,
12147
                                                  resolve_ctx_.sql_proxy_,
12148
                                                  resolve_ctx_.extern_param_info_,
12149
                                                  udf_info), udf_info);
12150
    } else {
12151
      ret = OB_ERR_UNEXPECTED;
12152
      LOG_WARN("Unexpected routine type",
12153
          K(routine_type), K(db_name), K(package_name), K(udf_name),
12154
          K(ret));
12155
    }
12156
    if (OB_SUCC(ret) && resolve_ctx_.is_sql_scope_ && OB_NOT_NULL(udf_info.ref_expr_) && udf_info.ref_expr_->has_param_out()) {
12157
      ret = OB_NOT_SUPPORTED;
12158
      LOG_WARN("You tried to execute a SQL statement that referenced a package or function\
12159
                that contained an OUT parameter. This is not allowed.", K(ret));
12160
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "ORA-06572: function name has out arguments");
12161
    }
12162
    if (OB_SUCC(ret) && !resolve_ctx_.is_sql_scope_) {
12163
      ObUDFRawExpr *udf_raw_expr = NULL;
12164
      const ObPLSymbolTable *table = current_block_->get_symbol_table();
12165
      CK (OB_NOT_NULL(table));
12166
      CK (OB_NOT_NULL(udf_raw_expr = udf_info.ref_expr_));
12167
      for (int64_t i = 0; OB_SUCC(ret) && i < udf_raw_expr->get_params_desc().count(); ++i) {
12168
        int64_t position = udf_raw_expr->get_param_position(i);
12169
        if (position != OB_INVALID_INDEX
12170
            && udf_raw_expr->get_params_desc().at(i).is_local_out()) {
12171
          const ObPLVar *var = NULL;
12172
          ObExprResType result_type;
12173
          CK (OB_NOT_NULL(var = table->get_symbol(position)));
12174
          if (OB_SUCC(ret) && var->is_readonly()) {
12175
            ret = OB_ERR_VARIABLE_IS_READONLY;
12176
            LOG_WARN("variable is read only", K(ret), K(position), KPC(var));
12177
          }
12178
          if (OB_SUCC(ret) && var->get_name().prefix_match(ANONYMOUS_ARG)) {
12179
            ObPLVar* shadow_var = const_cast<ObPLVar*>(var);
12180
            ObIRoutineParam *iparam = NULL;
12181
            OX (shadow_var->set_readonly(false));
12182
            CK (OB_NOT_NULL(routine_info));
12183
            OZ (routine_info->get_routine_param(i, iparam));
12184
            if (OB_SUCC(ret) && iparam->is_inout_param()) {
12185
              shadow_var->set_name(ANONYMOUS_INOUT_ARG);
12186
            }
12187
          }
12188
          if (OB_SUCC(ret)) {
12189
            const ObPLDataType &pl_type = var->get_type();
12190
            if (pl_type.is_obj_type()
12191
                && pl_type.get_data_type()->get_obj_type() != ObNullType) {
12192
              ObExprResTypes &params_type
12193
                = static_cast<ObExprResTypes&>(udf_raw_expr->get_params_type());
12194
              CK (OB_NOT_NULL(pl_type.get_data_type()));
12195
              OX (result_type = params_type.at(i));
12196
              OX (result_type.set_meta(pl_type.get_data_type()->get_meta_type()));
12197
              OX (result_type.set_accuracy(pl_type.get_data_type()->get_accuracy()));
12198
              OX (params_type[i] = result_type);
12199
            }
12200
            if (OB_SUCC(ret)) {
12201
              LOG_DEBUG("rewrite params type",
12202
                     K(ret), K(i), KPC(pl_type.get_data_type()),
12203
                     K(udf_raw_expr->get_params_type().at(i)),
12204
                     K(udf_raw_expr->get_params_type().at(i).get_accuracy()),
12205
                     K(result_type));
12206
            } else {
12207
              LOG_WARN("rewrite params type failed", K(ret), K(i), K(pl_type));
12208
            }
12209
          }
12210
        }
12211
      }
12212
    }
12213
    if (OB_SUCC(ret)) {
12214
      ObUDFRawExpr *udf_raw_expr = NULL;
12215
      CK (OB_NOT_NULL(udf_raw_expr = udf_info.ref_expr_));
12216
      OX (udf_raw_expr->set_is_udt_cons(udf_info.is_udf_udt_cons()));
12217
      OX (udf_raw_expr->set_is_udt_udf(routine_info->is_udt_routine()));
12218
      OX (udf_raw_expr->set_is_deterministic(routine_info->is_deterministic()));
12219
    }
12220
  }
12221
  return ret;
12222
}
12223

12224
int ObPLResolver::check_local_variable_read_only(
12225
  const ObPLBlockNS &ns, uint64_t var_idx, bool is_for_inout_param)
12226
{
12227
  int ret = OB_SUCCESS;
12228
  const ObPLVar *var = NULL;
12229
  const ObPLSymbolTable *symbol_table = NULL;
12230
  CK (OB_NOT_NULL(symbol_table = ns.get_symbol_table()));
12231
  OV (OB_NOT_NULL(var = symbol_table->get_symbol(var_idx)), OB_ERR_UNEXPECTED, K(var_idx));
12232
  if (OB_SUCC(ret)) {
12233
#define GET_TRIGGER_INFO  \
12234
  ObSchemaChecker schema_checker; \
12235
  const ObTriggerInfo *trg_info = NULL; \
12236
  const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();  \
12237
  OZ (schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid())); \
12238
  OZ (schema_checker.get_trigger_info(tenant_id, ns.get_db_name(), ns.get_package_name(), trg_info)); \
12239
  CK (OB_NOT_NULL(trg_info));
12240

12241
    // check type udf member function attr readable. etc: a := 5; when a is type object attr
12242
    // and this stmt is inside a object member function, it is not applicable.
12243
    // note: this statement is avaiable inside a member procedure
12244
    if (ns.get_symbol_table()->get_self_param_idx() == var_idx
12245
      && ns.function_block()
12246
      && ns.is_udt_routine()
12247
      && var->is_readonly()) {
12248
      ret = OB_ERR_EXP_NOT_ASSIGNABLE;
12249
      LOG_WARN("udt function attribute is read only", K(var_idx), K(ret),
12250
                                                      K(ns.function_block()),
12251
                                                      K(ns.is_udt_routine()));
12252
      LOG_USER_ERROR(OB_ERR_EXP_NOT_ASSIGNABLE, var->get_name().length(), var->get_name().ptr());
12253
    } else if(var->is_readonly()) {
12254
      // 匿名块的参数是可以写的, 记录下当前匿名块的参数被写过
12255
      if (var->get_name().prefix_match(ANONYMOUS_ARG)) {
12256
        ObPLVar *shadow_var = const_cast<ObPLVar*>(var);
12257
        shadow_var->set_readonly(false);
12258
        if (is_for_inout_param || var->is_referenced()) {
12259
          shadow_var->set_name(ANONYMOUS_INOUT_ARG);
12260
        }
12261
      } else {
12262
        if (lib::is_mysql_mode()) {
12263
          if (0 == var->get_name().case_compare("NEW")
12264
              && (TgTimingEvent::TG_AFTER_DELETE == resolve_ctx_.params_.tg_timing_event_
12265
                  || TgTimingEvent::TG_BEFORE_DELETE == resolve_ctx_.params_.tg_timing_event_)) {
12266
            ret = OB_ERR_TRIGGER_NO_SUCH_ROW;
12267
            LOG_WARN("There is no NEW row in on DELETE trigger", K(ret), K(resolve_ctx_.params_.tg_timing_event_));
12268
            LOG_USER_ERROR(OB_ERR_TRIGGER_NO_SUCH_ROW, "NEW", "DELETE");
12269
          } else {
12270
            ret = OB_ERR_TRIGGER_CANT_CHANGE_ROW;
12271
            if (0 == var->get_name().case_compare("NEW")) {
12272
              LOG_WARN("can not update NEW row in after trigger", K(var->get_name()), K(ret));
12273
              LOG_MYSQL_USER_ERROR(OB_ERR_TRIGGER_CANT_CHANGE_ROW, "NEW", "after ");
12274
            } else {
12275
              LOG_WARN("can not update OLD row in trigger", K(var->get_name()), K(ret));
12276
              LOG_MYSQL_USER_ERROR(OB_ERR_TRIGGER_CANT_CHANGE_ROW, "OLD", "");
12277
            }
12278
          }
12279
        } else if (resolve_ctx_.session_info_.is_for_trigger_package()
12280
                   && lib::is_oracle_mode()
12281
                   && ObTriggerInfo::is_trigger_body_package_id(ns.get_package_id())) {
12282
          GET_TRIGGER_INFO;
12283
          if (OB_FAIL(ret)) {
12284
          } else if (var->get_name().prefix_match(":")) {
12285
            ObString tmp(var->get_name().length() - 1, var->get_name().ptr() + 1);
12286
            if (0 == trg_info->get_ref_new_name().case_compare(tmp)) {
12287
              ret = OB_ERR_TRIGGER_CANT_CHANGE_ROW;
12288
              LOG_WARN("can not change NEW row in trigger", K(var->get_name()), K(ret));
12289
            } else if (0 == trg_info->get_ref_old_name().case_compare(tmp)) {
12290
              ret = OB_ERR_TRIGGER_CANT_CHANGE_OLD_ROW;
12291
              LOG_WARN("can not change OLD row in trigger", K(var->get_name()), K(ret));
12292
            }
12293
          }
12294
        } else {
12295
          ret = OB_ERR_VARIABLE_IS_READONLY;
12296
          LOG_WARN("variable is read only", K(ret), K(var_idx), KPC(var));
12297
        }
12298
      }
12299
    } else if (resolve_ctx_.session_info_.is_for_trigger_package()) {
12300
      if (ObTriggerInfo::is_trigger_body_package_id(ns.get_package_id()) && lib::is_oracle_mode()) {
12301
        GET_TRIGGER_INFO;
12302
        if (OB_SUCC(ret)
12303
            && (trg_info->has_delete_event() && !trg_info->has_update_event() && !trg_info->has_insert_event())) {
12304
          if (var->get_name().prefix_match(":")) {
12305
            ObString tmp(var->get_name().length() - 1, var->get_name().ptr() + 1);
12306
            if (0 == trg_info->get_ref_new_name().case_compare(tmp)) {
12307
              ret = OB_ERR_TRIGGER_CANT_CHANGE_ROW;
12308
              LOG_WARN("cannot change NEW values for this trigger type", K(var->get_name()), K(ret));
12309
            }
12310
          }
12311
        }
12312
      } else if (0 == var->get_name().case_compare("NEW") && lib::is_mysql_mode()
12313
                 && (TgTimingEvent::TG_AFTER_DELETE == resolve_ctx_.params_.tg_timing_event_
12314
                     || TgTimingEvent::TG_BEFORE_DELETE == resolve_ctx_.params_.tg_timing_event_)) {
12315
        ret = OB_ERR_TRIGGER_NO_SUCH_ROW;
12316
        LOG_WARN("there is no NEW row in on DELETE trigger", K(ret), K(resolve_ctx_.params_.tg_timing_event_));
12317
        LOG_USER_ERROR(OB_ERR_TRIGGER_NO_SUCH_ROW, "NEW", "DELETE");
12318
      }
12319
    }
12320
#undef GET_TRIGGER_INFO
12321
  }
12322
  return ret;
12323
}
12324

12325
int ObPLResolver::restriction_on_result_cache(ObIRoutineInfo *routine_info)
12326
{
12327
  int ret = OB_SUCCESS;
12328
  CK (OB_NOT_NULL(routine_info));
12329
  /*
12330
   * RESULT_CACHE is disallowed on functions with OUT or IN OUT parameters
12331
   * RESULT_CACHE is disallowed on functions with IN or RETURN parameter of (or
12332
   *  containing) these types:
12333
   *   – BLOB
12334
   *   – CLOB
12335
   *   – NCLOB
12336
   *   – REF CURSOR
12337
   *   – Collection
12338
   *   – Object
12339
   *   – Record or PL/SQL collection that contains an unsupported return type
12340
   */
12341
#define RESTRICTION_ON_TYPE(type) \
12342
  if (OB_FAIL(ret)) { \
12343
  } else if (type.is_obj_type() && (ob_is_text_tc(type.get_obj_type())  \
12344
              || ob_is_lob_tc(type.get_obj_type()))) { \
12345
    ret = OB_ERR_IMPL_RESTRICTION; \
12346
    LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION, \
12347
             "RESULT_CACHE is disallowed on subprograms with IN/RETURN" \
12348
             " parameter of (or containing) LOB type"); \
12349
  } else if (type.is_cursor_type()) { \
12350
    ret = OB_ERR_IMPL_RESTRICTION; \
12351
    LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION, \
12352
             "RESULT_CACHE is disallowed on subprograms with IN/RETURN" \
12353
             " parameter of (or containing) RefCursor type"); \
12354
  } else if (type.is_collection_type() && !type.is_udt_type()) { \
12355
    ret = OB_ERR_IMPL_RESTRICTION; \
12356
    LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION, \
12357
             "RESULT_CACHE is disallowed on subprograms with IN/RETURN" \
12358
             " parameter of (or containing) Collection type"); \
12359
  } else if (type.is_record_type() && !type.is_udt_type() && !type.is_rowtype_type()) { \
12360
    ret = OB_ERR_IMPL_RESTRICTION; \
12361
    LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION, \
12362
             "RESULT_CACHE is disallowed on subprograms with IN/RETURN" \
12363
             " parameter of (or containing) Record type"); \
12364
  }
12365

12366
  for (int64_t i = 0; OB_SUCC(ret) && i < routine_info->get_param_count(); ++i) {
12367
    ObIRoutineParam *param = NULL;
12368
    ObPLRoutineParamMode mode;
12369
    OZ (routine_info->get_routine_param(i, param));
12370
    CK (OB_NOT_NULL(param));
12371
    OX (mode = static_cast<ObPLRoutineParamMode>(param->get_mode()));
12372
    if (OB_SUCC(ret)) {
12373
      if (param->is_out_param() || param->is_inout_param()) {
12374
        ret = OB_ERR_IMPL_RESTRICTION;
12375
        LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION,
12376
                 "RESULT_CACHE is disallowed on subprograms with OUT or IN OUT parameters");
12377
      } else {
12378
        RESTRICTION_ON_TYPE(param->get_pl_data_type());
12379
      }
12380
    }
12381
  }
12382
  if (OB_SUCC(ret)) {
12383
    const ObIRoutineParam *ret_param = routine_info->get_ret_info();
12384
    CK (OB_NOT_NULL(ret_param));
12385
    RESTRICTION_ON_TYPE(ret_param->get_pl_data_type());
12386
  }
12387
#undef RESTRICTION_ON_TYPE
12388

12389
  return ret;
12390
}
12391

12392
int ObPLResolver::get_caller_accessor_item(const ObPLStmtBlock *caller, AccessorItem &caller_item)
12393
{
12394
  int ret = OB_SUCCESS;
12395
  const ObPLBlockNS *block_ns = NULL;
12396
  CK (OB_NOT_NULL(caller));
12397
  CK (OB_NOT_NULL(block_ns = &(caller->get_namespace())));
12398
  if (OB_SUCC(ret)) {
12399
    if (block_ns->get_package_id() != OB_INVALID_ID) {
12400
      if (ObTriggerInfo::is_trigger_package_id(block_ns->get_package_id())) { //trigger
12401
        caller_item.kind_ = AccessorItemKind::PL_ACCESSOR_TRIGGER;
12402
        caller_item.schema_ = block_ns->get_db_name();
12403
        caller_item.name_ = block_ns->get_package_name();
12404
      } else { //package
12405
        caller_item.kind_ = AccessorItemKind::PL_ACCESSOR_PACKAGE;
12406
        caller_item.name_ = block_ns->get_package_name();
12407
      }
12408
    } else if (block_ns->function_block()) {
12409
      caller_item.kind_ = AccessorItemKind::PL_ACCESSOR_FUNCTION;
12410
      caller_item.schema_ = block_ns->get_db_name();
12411
      caller_item.name_ = block_ns->get_routine_name();
12412
    } else {
12413
      caller_item.kind_ = AccessorItemKind::PL_ACCESSOR_PROCEDURE;
12414
      caller_item.schema_ = block_ns->get_db_name();
12415
      caller_item.name_ = block_ns->get_routine_name();
12416
    }
12417
    if (caller_item.schema_.empty()) {
12418
      caller_item.schema_ = resolve_ctx_.session_info_.get_database_name();
12419
    }
12420
  }
12421
  return ret;
12422
}
12423

12424
int ObPLResolver::check_package_accessible(
12425
  const ObPLStmtBlock *caller, ObSchemaGetterGuard &guard, uint64_t package_id)
12426
{
12427
  int ret = OB_SUCCESS;
12428
  CK (OB_NOT_NULL(caller));
12429
  if (OB_SUCC(ret)
12430
      && OB_INVALID_ID != package_id
12431
      && package_id != caller->get_namespace().get_package_id()) {
12432
    const ObPackageInfo *pkg_info = NULL;
12433
    AccessorItem caller_item;
12434
    const uint64_t tenant_id = get_tenant_id_by_object_id(package_id);
12435
    OZ (guard.get_package_info(tenant_id, package_id, pkg_info));
12436
    CK (OB_NOT_NULL(pkg_info));
12437
    if (OB_SUCC(ret) && pkg_info->has_accessible_by_clause()) {
12438
      OZ (get_caller_accessor_item(caller, caller_item));
12439
      OZ (check_package_accessible(caller_item, pkg_info->get_source()));
12440
    }
12441
  }
12442
  return ret;
12443
}
12444

12445
int ObPLResolver::check_package_accessible(
12446
  const ObPLStmtBlock *caller, ObSchemaGetterGuard &guard, const ObPLRoutineInfo &routine_info)
12447
{
12448
  int ret = OB_SUCCESS;
12449
  if (routine_info.has_accessible_by_clause()) {
12450
    AccessorItem caller_item;
12451
    CK (OB_NOT_NULL(caller));
12452
    OZ (check_package_accessible(caller, guard, routine_info.get_pkg_id()));
12453
    OZ (get_caller_accessor_item(caller, caller_item));
12454
    OZ (check_routine_accessible(caller_item, routine_info.get_routine_body()));
12455
  }
12456
  return ret;
12457
}
12458

12459
int ObPLResolver::check_routine_accessible(
12460
  const ObPLStmtBlock *caller, ObSchemaGetterGuard &guard, const ObRoutineInfo& routine_info)
12461
{
12462
  int ret = OB_SUCCESS;
12463
  if (routine_info.has_accessible_by_clause()) {
12464
    AccessorItem caller_item;
12465
    CK (OB_NOT_NULL(caller));
12466
    if (OB_SUCC(ret) && routine_info.get_package_id() != OB_INVALID_ID) {
12467
      OZ (check_package_accessible(caller, guard, routine_info.get_package_id()));
12468
    }
12469
    OZ (get_caller_accessor_item(caller, caller_item));
12470
    OZ (check_routine_accessible(caller_item, routine_info.get_routine_body()));
12471
  }
12472
  return ret;
12473
}
12474

12475
int ObPLResolver::check_package_accessible(
12476
  AccessorItem &caller, const ObString &package_body)
12477
{
12478
  int ret = OB_SUCCESS;
12479
  ObSEArray<AccessorItem, 4> accessors;
12480
  OZ (resolve_package_accessible_by(package_body, accessors));
12481
  OZ (check_common_accessible(caller, accessors));
12482
  return ret;
12483
}
12484

12485
int ObPLResolver::check_routine_accessible(
12486
  AccessorItem &caller, const ObString &routine_body)
12487
{
12488
  int ret = OB_SUCCESS;
12489
  ObSEArray<AccessorItem, 4> accessors;
12490
  OZ (resolve_routine_accessible_by(routine_body, accessors));
12491
  OZ (check_common_accessible(caller, accessors));
12492
  return ret;
12493
}
12494

12495
int ObPLResolver::check_common_accessible(
12496
  AccessorItem &caller, ObIArray<AccessorItem> &accessors)
12497
{
12498
  int ret = OB_SUCCESS;
12499
  bool found = false;
12500
  for (int64_t i = 0; OB_SUCC(ret) && !found && i < accessors.count(); ++i) {
12501
    AccessorItem &accessor = accessors.at(i);
12502
    if (0 == accessor.name_.case_compare(caller.name_)
12503
        && 0 == accessor.schema_.case_compare(caller.schema_)
12504
        && (accessor.kind_ == caller.kind_
12505
            || AccessorItemKind::PL_ACCESSOR_ALL == accessor.kind_)) {
12506
      found = true;
12507
    }
12508
  }
12509
  if (!found && accessors.count() > 0) {
12510
    ret = OB_ERR_INSUFFICIENT_PRIVILEGE;
12511
    LOG_WARN("PLS-00904: insufficient privilege to access object string",
12512
             K(ret), K(caller), K(accessors));
12513
  }
12514
  return ret;
12515
}
12516

12517
int ObPLResolver::resolve_accessible_by(
12518
  const ObStmtNodeTree *accessor_list, ObIArray<AccessorItem> &result)
12519
{
12520
  int ret = OB_SUCCESS;
12521
  CK (OB_NOT_NULL(accessor_list));
12522
  for (int64_t i = 0; OB_SUCC(ret) && i < accessor_list->num_child_; ++i) {
12523
    const ObStmtNodeTree *accessor = accessor_list->children_[i];
12524
    const ObStmtNodeTree *kind = NULL;
12525
    const ObStmtNodeTree *name = NULL;
12526
    CK (OB_NOT_NULL(accessor));
12527
    CK (T_SP_ACCESSOR == accessor->type_);
12528
    CK (2 == accessor->num_child_);
12529
    OX (kind = accessor->children_[0]);
12530
    CK (OB_NOT_NULL(name = accessor->children_[1]));
12531
    CK (2 == name->num_child_);
12532
    CK (OB_NOT_NULL(name->children_[1]));
12533
    if (OB_SUCC(ret)) {
12534
      ObString schema_name;
12535
      ObString item_name;
12536
      OZ (ob_write_string(resolve_ctx_.allocator_,
12537
                          ObString(name->children_[1]->str_len_, name->children_[1]->str_value_),
12538
                          item_name));
12539
      if (OB_NOT_NULL(name->children_[0])) {
12540
        OZ (ob_write_string(resolve_ctx_.allocator_,
12541
                          ObString(name->children_[0]->str_len_, name->children_[0]->str_value_),
12542
                          schema_name));
12543
      } else {
12544
        schema_name = resolve_ctx_.session_info_.get_database_name();
12545
      }
12546
      if (OB_FAIL(ret)) {
12547
      } else if (OB_ISNULL(kind)) {
12548
        OZ (result.push_back(
12549
          AccessorItem(AccessorItemKind::PL_ACCESSOR_ALL, schema_name, item_name)));
12550
      } else {
12551
        AccessorItemKind item_kind = PL_ACCESSOR_INVALID;
12552
        switch(kind->value_) {
12553
          case SP_FUNCTION: {
12554
            item_kind = AccessorItemKind::PL_ACCESSOR_FUNCTION;
12555
            break;
12556
          }
12557
          case SP_PROCEDURE: {
12558
            item_kind = AccessorItemKind::PL_ACCESSOR_PROCEDURE;
12559
            break;
12560
          }
12561
          case SP_PACKAGE: {
12562
            item_kind = AccessorItemKind::PL_ACCESSOR_PACKAGE;
12563
            break;
12564
          }
12565
          case SP_TRIGGER: {
12566
            item_kind = AccessorItemKind::PL_ACCESSOR_TRIGGER;
12567
            break;
12568
          }
12569
          case SP_TYPE: {
12570
            item_kind = AccessorItemKind::PL_ACCESSOR_TYPE;
12571
            break;
12572
          }
12573
          default: {
12574
            ret = OB_ERR_UNEXPECTED;
12575
            LOG_WARN("unexpected accessor kind node", K(ret), K(kind));
12576
          }
12577
        }
12578
        OZ (result.push_back(AccessorItem(item_kind, schema_name, item_name)));
12579
      }
12580
    }
12581
  }
12582
  return ret;
12583
}
12584

12585
int ObPLResolver::resolve_package_accessible_by(
12586
  const ObString source, ObIArray<AccessorItem> &result)
12587
{
12588
  int ret = OB_SUCCESS;
12589
  ObArenaAllocator allocator;
12590
  ObPLParser parser(allocator, ObCharsets4Parser(), resolve_ctx_.session_info_.get_sql_mode());
12591
  ObStmtNodeTree *parse_tree = NULL;
12592
  const ObStmtNodeTree *package_node = NULL;
12593
  const ObStmtNodeTree *clause_node = NULL;
12594
  CK (lib::is_oracle_mode());
12595
  OZ (parser.parse_package(source, parse_tree, resolve_ctx_.session_info_.get_dtc_params(), NULL, false));
12596
  CK (OB_NOT_NULL(parse_tree));
12597
  CK (T_STMT_LIST == parse_tree->type_);
12598
  CK (1 == parse_tree->num_child_);
12599
  CK (OB_NOT_NULL(package_node = parse_tree->children_[0]));
12600
  if (OB_SUCC(ret) && T_SP_PRE_STMTS == parse_tree->type_) {
12601
    OZ (ObPLResolver::resolve_condition_compile(
12602
      resolve_ctx_.allocator_,
12603
      &(resolve_ctx_.session_info_),
12604
      &(resolve_ctx_.schema_guard_),
12605
      &(resolve_ctx_.package_guard_),
12606
      &(resolve_ctx_.sql_proxy_),
12607
      NULL,
12608
      package_node,
12609
      package_node,
12610
      true /*inner_parse*/));
12611
  }
12612
  CK (OB_NOT_NULL(package_node));
12613
  CK (T_PACKAGE_BLOCK == package_node->type_);
12614
  CK (4 == package_node->num_child_);
12615
  OX (clause_node = package_node->children_[1]);
12616
  for (int64_t i = 0;
12617
      OB_SUCC(ret) && OB_NOT_NULL(clause_node) && i < clause_node->num_child_; ++i) {
12618
    const ObStmtNodeTree *child = clause_node->children_[i];
12619
    if (OB_NOT_NULL(child) && T_SP_ACCESSIBLE_BY == child->type_) {
12620
      const ObStmtNodeTree *accessor_list = NULL;
12621
      CK (1 == child->num_child_);
12622
      OX (accessor_list = child->children_[0]);
12623
      CK (OB_NOT_NULL(accessor_list));
12624
      CK (T_SP_ACCESSOR_LIST == accessor_list->type_);
12625
      OZ (resolve_accessible_by(accessor_list, result));
12626
    }
12627
  }
12628
  return ret;
12629
}
12630

12631
int ObPLResolver::resolve_routine_accessible_by(
12632
  const ObString source, ObIArray<AccessorItem> &result)
12633
{
12634
  int ret = OB_SUCCESS;
12635
  ObArenaAllocator allocator;
12636
  ObPLParser parser(allocator, ObCharsets4Parser(), resolve_ctx_.session_info_.get_sql_mode());
12637
  ObStmtNodeTree *parse_tree = NULL;
12638
  const ObStmtNodeTree *routine_node = NULL;
12639
  const ObStmtNodeTree *clause_node = NULL;
12640
  CK (lib::is_oracle_mode());
12641
  OZ (parser.parse_routine_body(source, parse_tree, false), source);
12642
  CK (OB_NOT_NULL(parse_tree->children_));
12643
  CK (1 == parse_tree->num_child_);
12644
  CK (OB_NOT_NULL(parse_tree->children_[0]));
12645
  OX (routine_node = parse_tree->children_[0]);
12646
  if (OB_SUCC(ret) && T_SP_PRE_STMTS == routine_node->type_) {
12647
    OZ (ObPLResolver::resolve_condition_compile(
12648
      resolve_ctx_.allocator_,
12649
      &(resolve_ctx_.session_info_),
12650
      &(resolve_ctx_.schema_guard_),
12651
      &(resolve_ctx_.package_guard_),
12652
      &(resolve_ctx_.sql_proxy_),
12653
      NULL,
12654
      routine_node,
12655
      routine_node,
12656
      true /*inner_parse*/));
12657
  }
12658
  CK (OB_NOT_NULL(routine_node));
12659
  CK (T_SF_SOURCE == routine_node->type_ || T_SP_SOURCE == routine_node->type_);
12660
  if (OB_SUCC(ret)) {
12661
    if (T_SF_SOURCE == routine_node->type_) {
12662
      clause_node = routine_node->children_[3];
12663
    } else {
12664
      clause_node = routine_node->children_[2];
12665
    }
12666
  }
12667
  for (int64_t i = 0;
12668
       OB_SUCC(ret) && OB_NOT_NULL(clause_node) && i < clause_node->num_child_; ++i) {
12669
    const ObStmtNodeTree *child = clause_node->children_[i];
12670
    if (OB_NOT_NULL(child) && T_SP_ACCESSIBLE_BY == child->type_) {
12671
      const ObStmtNodeTree *accessor_list = NULL;
12672
      CK (1 == child->num_child_);
12673
      OX (accessor_list = child->children_[0]);
12674
      CK (OB_NOT_NULL(accessor_list));
12675
      CK (T_SP_ACCESSOR_LIST == accessor_list->type_);
12676
      OZ (resolve_accessible_by(accessor_list, result));
12677
    }
12678
  }
12679
  return ret;
12680
}
12681

12682
int ObPLResolver::resolve_sf_clause(
12683
  const ObStmtNodeTree *node, ObIRoutineInfo *routine_info, ObProcType &routine_type, const ObPLDataType &ret_type)
12684
{
12685
  int ret = OB_SUCCESS;
12686
  CK (OB_NOT_NULL(node));
12687
  CK (OB_NOT_NULL(routine_info));
12688
  CK (T_SP_CLAUSE_LIST == node->type_);
12689
  for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
12690
    const ObStmtNodeTree *child = node->children_[i];
12691
    bool has_invoker_clause = false;
12692
    if (OB_NOT_NULL(child)) {
12693
      if (T_SP_DETERMINISTIC == child->type_) {
12694
        if (routine_info->is_deterministic()) {
12695
          ret = OB_ERR_DECL_MORE_THAN_ONCE;
12696
          LOG_WARN("PLS-00371: at most one declaration for 'string' is permitted",
12697
                   K(ret), K(child->type_));
12698
        } else {
12699
          routine_info->set_deterministic();
12700
        }
12701
      } else if (T_SP_PARALLEL_ENABLE == child->type_) {
12702
        if (routine_info->is_parallel_enable()) {
12703
          ret = OB_ERR_DECL_MORE_THAN_ONCE;
12704
          LOG_WARN("PLS-00371: at most one declaration for 'string' is permitted",
12705
                   K(ret), K(child->type_));
12706
        } else if (child->num_child_ > 0) {
12707
          ret = OB_NOT_SUPPORTED;
12708
          LOG_WARN("not support partition by clause in parallel enable clause", K(ret), K(child));
12709
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "partition by clause in parallel enable clause");
12710
        } else if (ObProcType::NESTED_FUNCTION == routine_type
12711
                   || ObProcType::NESTED_PROCEDURE == routine_type) {
12712
          ret = OB_ERR_ILLEGAL_OPTION;
12713
          LOG_WARN("PLS-00712: illegal option for subprogram string", K(ret));
12714
        } else {
12715
          routine_info->set_parallel_enable();
12716
        }
12717
      } else if (T_SP_INVOKE == child->type_) {
12718
        if (has_invoker_clause) {
12719
          ret = OB_ERR_DECL_MORE_THAN_ONCE;
12720
          LOG_WARN("PLS-00371: at most one declaration for 'string' is permitted",
12721
                   K(ret), K(child->type_));
12722
        } else if (ObProcType::STANDALONE_FUNCTION != routine_type
12723
                   && ObProcType::STANDALONE_PROCEDURE != routine_type) {
12724
          ret = OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW;
12725
          LOG_USER_ERROR(OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW, "AUTHID");
12726
        } else {
12727
          has_invoker_clause = true;
12728
          if (lib::is_oracle_mode() && SP_CURRENT_USER == child->value_) {
12729
            routine_info->set_invoker_right();
12730
          } else if (lib::is_mysql_mode() && SP_INVOKER == child->value_) {
12731
            routine_info->set_invoker_right();
12732
          }
12733
        }
12734
      } else if (T_SP_RESULT_CACHE == child->type_) {
12735
        /* This RELIES_ON clause is deprecated. As of Oracle Database 12c, the database
12736
         * detects all data sources that are queried while a result-cached function is
12737
         * running, and RELIES_ON clause does nothing. */
12738
        if (routine_info->is_result_cache()) {
12739
          ret = OB_ERR_DECL_MORE_THAN_ONCE;
12740
          LOG_WARN("PLS-00371: at most one declaration for 'string' is permitted",
12741
                   K(ret), K(child->type_));
12742
        } else if (ObProcType::NESTED_FUNCTION == routine_type
12743
                   || ObProcType::NESTED_PROCEDURE == routine_type) {
12744
          ret = OB_ERR_IMPL_RESTRICTION;
12745
          LOG_USER_ERROR(OB_ERR_IMPL_RESTRICTION,
12746
                         "RESULT_CACHE on subprograms in anonymous blocks is");
12747
        } else {
12748
          OZ (restriction_on_result_cache(routine_info));
12749
          OX (routine_info->set_result_cache());
12750
        }
12751
      } else if (T_SP_ACCESSIBLE_BY == child->type_) {
12752
        if (routine_info->has_accessible_by_clause()) {
12753
          ret = OB_ERR_DECL_MORE_THAN_ONCE;
12754
          LOG_WARN("PLS-00371: at most one declaration for 'string' is permitted",
12755
                   K(ret), K(child->type_));
12756
        } else if (ObProcType::NESTED_FUNCTION == routine_type
12757
                   || ObProcType::NESTED_PROCEDURE == routine_type) {
12758
          ret = OB_ERR_MISMATCH_SUBPROGRAM;
12759
          LOG_WARN("PLS-00263: mismatch between string on a subprogram specification and body",
12760
                   K(ret), K(child->type_));
12761
        } else {
12762
          routine_info->set_accessible_by_clause();
12763
        }
12764
      } else if (T_SP_PIPELINED == child->type_) {
12765
        CK (OB_NOT_NULL(routine_info->get_ret_info()));
12766
        if (OB_SUCC(ret)) {
12767
          if (PACKAGE_FUNCTION != routine_type && NESTED_FUNCTION != routine_type
12768
              && STANDALONE_FUNCTION != routine_type && UDT_FUNCTION != routine_type) {
12769
            ret = OB_ERR_ONLY_FUNC_CAN_PIPELINED;
12770
            LOG_WARN("only functions can be declared as PIPELINED", K(ret));
12771
          } else if (!ret_type.is_nested_table_type() && !ret_type.is_varray_type()) {
12772
            ret = OB_ERR_PIPE_RETURN_NOT_COLL;
12773
            LOG_WARN("pipelined functions must have a supported collection return type",
12774
                     K(ret_type.get_type()), K(ret));
12775
          }
12776
          OX (routine_info->set_pipelined());
12777
        }
12778
      } else if (T_COMMENT == child->type_) {
12779
        if (lib::is_mysql_mode()) {
12780
          ObString routine_comment;
12781
          CK (OB_NOT_NULL(dynamic_cast<ObRoutineInfo*>(routine_info)));
12782
          OX (routine_comment = ObString(child->str_len_, child->str_value_));
12783
          OZ (dynamic_cast<ObRoutineInfo*>(routine_info)->set_comment(routine_comment));
12784
        }
12785
      } else if (T_SP_DATA_ACCESS == child->type_) {
12786
        if (lib::is_mysql_mode()) {
12787
          if (SP_NO_SQL == child->value_) {
12788
            routine_info->set_no_sql();
12789
          } else if (SP_READS_SQL_DATA == child->value_) {
12790
            routine_info->set_reads_sql_data();
12791
          } else if (SP_MODIFIES_SQL_DATA == child->value_) {
12792
            routine_info->set_modifies_sql_data();
12793
          } else if (SP_CONTAINS_SQL == child->value_) {
12794
            routine_info->set_contains_sql();
12795
          }
12796
        }
12797
      }
12798
    }
12799
  }
12800
  return ret;
12801
}
12802

12803
int ObPLResolver::get_local_variable_constraint(
12804
  const ObPLBlockNS &ns, int64_t var_idx, bool &not_null, ObPLIntegerRange &range)
12805
{
12806
  int ret = OB_SUCCESS;
12807
  const ObPLVar *var = NULL;
12808
  CK (OB_NOT_NULL(ns.get_symbol_table()));
12809
  CK (OB_NOT_NULL(var = ns.get_symbol_table()->get_symbol(var_idx)));
12810
  CK (OB_NOT_NULL(var));
12811
  OX (not_null = var->is_not_null());
12812
  OX (var->get_type().is_pl_integer_type() ?
12813
        range.set_range(var->get_type().get_range()) : void(NULL));
12814
  return ret;
12815
}
12816

12817
int ObPLResolver::get_subprogram_ns(
12818
  ObPLBlockNS &current_ns, uint64_t subprogram_id, ObPLBlockNS *&subprogram_ns)
12819
{
12820
  int ret = OB_SUCCESS;
12821
  if (current_ns.get_routine_id() == subprogram_id) {
12822
    subprogram_ns = &current_ns;
12823
  } else if (OB_NOT_NULL(current_ns.get_external_ns())
12824
             && OB_NOT_NULL(current_ns.get_external_ns()->get_parent_ns())) {
12825
    OZ (get_subprogram_ns(
12826
      *(const_cast<ObPLBlockNS *>(current_ns.get_external_ns()->get_parent_ns())),
12827
      subprogram_id, subprogram_ns));
12828
  } else {
12829
    ret = OB_ERR_UNEXPECTED;
12830
    LOG_WARN("can not found subprogram namespace",
12831
             K(ret), K(subprogram_id), K(current_ns.get_routine_id()));
12832
  }
12833
  return ret;
12834
}
12835

12836
int ObPLResolver::get_subprogram_var(
12837
  ObPLBlockNS &ns, uint64_t subprogram_id, int64_t var_idx, const ObPLVar *&var)
12838
{
12839
  int ret = OB_SUCCESS;
12840
  ObPLBlockNS *subprogram_ns = NULL;
12841
  const ObPLSymbolTable *symbol_table = NULL;
12842
  OZ (get_subprogram_ns(ns, subprogram_id, subprogram_ns));
12843
  CK (OB_NOT_NULL(subprogram_ns));
12844
  CK (OB_NOT_NULL(symbol_table = subprogram_ns->get_symbol_table()));
12845
  OV (OB_NOT_NULL(var = symbol_table->get_symbol(var_idx)),
12846
    OB_ERR_UNEXPECTED, K(var_idx), K(subprogram_id), K(symbol_table->get_count()));
12847
  return ret;
12848
}
12849

12850
int ObPLResolver::check_subprogram_variable_read_only(
12851
  ObPLBlockNS &ns, uint64_t subprogram_id, int64_t var_idx)
12852
{
12853
  int ret = OB_SUCCESS;
12854
  ObPLBlockNS *subprogram_ns = NULL;
12855
  OZ (get_subprogram_ns(ns, subprogram_id, subprogram_ns));
12856
  CK (OB_NOT_NULL(subprogram_ns));
12857
  OZ (check_local_variable_read_only(*subprogram_ns, var_idx));
12858
  return ret;
12859
}
12860

12861
int ObPLResolver::check_package_variable_read_only(uint64_t package_id, uint64_t var_idx)
12862
{
12863
  int ret = OB_SUCCESS;
12864
  bool is_local = false;
12865

12866
  const ObPLBlockNS *ns = &(current_block_->get_namespace());
12867
  do {
12868
    if (ns->get_block_type() != ObPLBlockNS::BLOCK_ROUTINE
12869
      && ns->get_package_id() == package_id) {
12870
      break;
12871
    } else {
12872
      const ObPLBlockNS *pre_ns = ns->get_pre_ns();
12873
      if (OB_NOT_NULL(ns->get_pre_ns())) {
12874
        ns = ns->get_pre_ns();
12875
      } else if (OB_NOT_NULL(ns->get_external_ns())) {
12876
        ns = ns->get_external_ns()->get_parent_ns();
12877
      } else {
12878
        ns = NULL;
12879
      }
12880
    }
12881
  } while (OB_NOT_NULL(ns));
12882

12883
  if (OB_NOT_NULL(ns)) {
12884
    is_local = true;
12885
    OZ (check_local_variable_read_only(*ns, var_idx));
12886
  }
12887

12888
  if (OB_SUCC(ret) && !is_local) {
12889
    const ObPLVar *var = NULL;
12890
    ObPLPackageManager &package_manager =
12891
        resolve_ctx_.session_info_.get_pl_engine()->get_package_manager();
12892
    OZ (package_manager.get_package_var(resolve_ctx_, package_id, var_idx, var));
12893
    CK (OB_NOT_NULL(var));
12894
    if (OB_SUCC(ret) && var->is_readonly()) {
12895
      ret = OB_ERR_VARIABLE_IS_READONLY;
12896
      LOG_WARN("variable is read only", K(ret), K(package_id), K(var_idx));
12897
    }
12898
  }
12899
  return ret;
12900
}
12901

12902
int ObPLResolver::check_variable_accessible(
12903
        const ObPLBlockNS &ns, const ObIArray<ObObjAccessIdx>& access_idxs, bool for_write)
12904
{
12905
  int ret = OB_SUCCESS;
12906
  CK (!access_idxs.empty());
12907
  if (OB_FAIL(ret)) {
12908
  } else if (for_write && OB_FAIL(check_update_column(ns, access_idxs))) {
12909
    LOG_WARN("check update column failed", K(ret));
12910
  } else if (ObObjAccessIdx::is_local_variable(access_idxs)) {
12911
    if (for_write) {
12912
      OZ (check_local_variable_read_only(
12913
        ns, access_idxs.at(ObObjAccessIdx::get_local_variable_idx(access_idxs)).var_index_
12914
        /*access_idxs.at(access_idxs.count() - 1).var_index_*/), access_idxs);
12915
    } else {
12916
      ObPLVar *var = NULL;
12917
      const ObPLSymbolTable *symbol_table = NULL;
12918
      int64_t idx = access_idxs.at(ObObjAccessIdx::get_local_variable_idx(access_idxs)).var_index_;
12919
      CK (OB_NOT_NULL(symbol_table = ns.get_symbol_table()));
12920
      OV (OB_NOT_NULL(var = const_cast<ObPLVar *>(symbol_table->get_symbol(idx))), OB_ERR_UNEXPECTED, K(idx));
12921
      OX (var->set_is_referenced(true));
12922
    }
12923
  } else if (ObObjAccessIdx::is_package_variable(access_idxs)) {
12924
    if ((for_write && ns.get_compile_flag().compile_with_wnps())
12925
        || (!for_write && ns.get_compile_flag().compile_with_rnps())) {
12926
      ret = OB_ERR_SUBPROGRAM_VIOLATES_PRAGMA;
12927
      LOG_WARN("PLS-00452: Subprogram 'string' violates its associated pragma",
12928
               K(ret), K(ns.get_compile_flag()));
12929
    } else {
12930
      uint64_t package_id = OB_INVALID_ID;
12931
      uint64_t var_idx = OB_INVALID_ID;
12932
      OZ (ObObjAccessIdx::get_package_id(access_idxs, package_id, var_idx));
12933
      if (OB_SUCC(ret) && for_write) {
12934
        const ObPLBlockNS *iter_ns = &ns;
12935
        while (OB_NOT_NULL(iter_ns)) {
12936
          if ((ObPLBlockNS::BlockType::BLOCK_PACKAGE_SPEC == iter_ns->get_block_type()
12937
                || ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY == iter_ns->get_block_type())
12938
              && iter_ns->get_package_id() == package_id) {
12939
            break;
12940
          } else {
12941
            iter_ns = OB_NOT_NULL(iter_ns->get_external_ns())
12942
                        ? iter_ns->get_external_ns()->get_parent_ns() : NULL;
12943
          }
12944
        }
12945
        if (OB_NOT_NULL(iter_ns)) {
12946
          OZ (check_local_variable_read_only(*iter_ns, var_idx));
12947
        } else {
12948
          OZ (check_package_variable_read_only(package_id, var_idx));
12949
        }
12950
      }
12951
      OZ (check_package_accessible(current_block_, resolve_ctx_.schema_guard_, package_id));
12952
    }
12953
  } else if (ObObjAccessIdx::is_subprogram_variable(access_idxs)) {
12954
    if (for_write) {
12955
      const ObPLBlockNS *subprogram_ns = NULL;
12956
      const ObRawExpr *f_expr = NULL;
12957
      int64_t subprogram_idx = OB_INVALID_INDEX;
12958
      OX (subprogram_idx = ObObjAccessIdx::get_subprogram_idx(access_idxs));
12959
      CK (subprogram_idx != OB_INVALID_INDEX
12960
          && subprogram_idx >= 0 && subprogram_idx < access_idxs.count());
12961
      OX (subprogram_ns = access_idxs.at(subprogram_idx).var_ns_);
12962
      CK (OB_NOT_NULL(subprogram_ns));
12963
      OX (f_expr = access_idxs.at(subprogram_idx).get_sysfunc_);
12964
      CK (OB_NOT_NULL(f_expr));
12965
      if (T_OP_GET_SUBPROGRAM_VAR == f_expr->get_expr_type()) {
12966
        uint64_t actual_var_idx = OB_INVALID_INDEX;
12967
        OZ (get_const_expr_value(f_expr->get_param_expr(2), actual_var_idx));
12968
        OZ (check_local_variable_read_only(*subprogram_ns, actual_var_idx));
12969
      } else {
12970
        OZ (check_local_variable_read_only(
12971
          *subprogram_ns, access_idxs.at(subprogram_idx).var_index_));
12972
      }
12973
    }
12974
  } else if (ObObjAccessIdx::is_get_variable(access_idxs)) {
12975
    // do nothing ...
12976
  } else if (ObObjAccessIdx::is_function_return_variable(access_idxs)) {
12977
    if (for_write) {
12978
      ret = OB_ERR_VARIABLE_IS_READONLY;
12979
      LOG_WARN("function return variable is read only", K(ret));
12980
    }
12981
  } else {
12982
    ret = OB_ERR_UNEXPECTED;
12983
    LOG_WARN("unknow variable type", K(ret), K(access_idxs));
12984
  }
12985
  return ret;
12986
}
12987

12988
int ObPLResolver::get_const_expr_value(const ObRawExpr *expr, uint64_t &val)
12989
{
12990
  int ret = OB_SUCCESS;
12991
  const ObConstRawExpr *c_expr = static_cast<const ObConstRawExpr*>(expr);
12992
  CK (OB_NOT_NULL(c_expr));
12993
  CK (c_expr->get_value().is_uint64()
12994
      || c_expr->get_value().is_int()
12995
      || c_expr->get_value().is_unknown());
12996
  OX (val = c_expr->get_value().is_uint64() ? c_expr->get_value().get_uint64()
12997
        : c_expr->get_value().is_int() ? c_expr->get_value().get_int()
12998
        : c_expr->get_value().get_unknown());
12999
  return ret;
13000
}
13001

13002
int ObPLResolver::check_variable_accessible(ObRawExpr *expr, bool for_write)
13003
{
13004
  int ret = OB_SUCCESS;
13005

13006
#define GET_CONST_EXPR_VALUE(expr, val) get_const_expr_value(expr, val)
13007

13008
  CK (OB_NOT_NULL(expr));
13009
  CK (OB_NOT_NULL(current_block_));
13010
  if (OB_FAIL(ret)) {
13011
  } else if (expr->is_obj_access_expr()) {
13012
    ObObjAccessRawExpr *obj_access = static_cast<ObObjAccessRawExpr*>(expr);
13013
    CK (OB_NOT_NULL(obj_access));
13014
    if (OB_FAIL(ret)) {
13015
    } else if (ObObjAccessIdx::is_local_variable(obj_access->get_access_idxs())) {
13016
      if (for_write) {
13017
        ObIArray<ObObjAccessIdx> &access_idxs = obj_access->get_access_idxs();
13018
        int64_t var_idx =
13019
          access_idxs.at(ObObjAccessIdx::get_local_variable_idx(access_idxs)).var_index_;
13020
        CK (var_idx >= 0 && var_idx < obj_access->get_var_indexs().count());
13021
        OZ (check_local_variable_read_only(
13022
          current_block_->get_namespace(), obj_access->get_var_indexs().at(var_idx)));
13023
      }
13024
    } else if (ObObjAccessIdx::is_subprogram_variable(obj_access->get_access_idxs()) && for_write) {
13025
      const ObPLBlockNS *subprogram_ns = NULL;
13026
      const ObRawExpr *f_expr = NULL;
13027
      ObIArray<ObObjAccessIdx> &access_idxs = obj_access->get_access_idxs();
13028
      int64_t subprogram_idx = access_idxs.at(ObObjAccessIdx::get_subprogram_idx(access_idxs)).var_index_;
13029
      CK (subprogram_idx != OB_INVALID_INDEX
13030
          && subprogram_idx >= 0 && subprogram_idx < access_idxs.count());
13031
      OX (subprogram_ns = access_idxs.at(subprogram_idx).var_ns_);
13032
      CK (OB_NOT_NULL(subprogram_ns));
13033
      OX (f_expr = obj_access->get_param_expr(subprogram_idx));
13034
      CK (OB_NOT_NULL(f_expr));
13035
      if (T_OP_GET_SUBPROGRAM_VAR == f_expr->get_expr_type()) {
13036
        uint64_t actual_var_idx = OB_INVALID_INDEX;
13037
        GET_CONST_EXPR_VALUE(f_expr->get_param_expr(2), actual_var_idx);
13038
        OZ (check_local_variable_read_only(*subprogram_ns, actual_var_idx));
13039
      } else {
13040
        OZ (check_variable_accessible(current_block_->get_namespace(),
13041
                                  obj_access->get_access_idxs(),
13042
                                  for_write),
13043
                                  obj_access->get_access_idxs(), expr);
13044
      }
13045
    } else {
13046
      OZ (check_variable_accessible(current_block_->get_namespace(),
13047
                                   obj_access->get_access_idxs(),
13048
                                   for_write),
13049
                                   obj_access->get_access_idxs(), expr);
13050
    }
13051
  } else if (expr->is_const_raw_expr()) {
13052
    if (for_write) {
13053
      uint64_t var_idx = OB_INVALID_ID;
13054
      GET_CONST_EXPR_VALUE(expr, var_idx);
13055
      OZ (check_local_variable_read_only(current_block_->get_namespace(), var_idx));
13056
    }
13057
  } else if (expr->is_sys_func_expr()
13058
             && T_OP_GET_PACKAGE_VAR == expr->get_expr_type()) {
13059
    const ObSysFunRawExpr *f_expr = static_cast<const ObSysFunRawExpr *>(expr);
13060
    uint64_t package_id = OB_INVALID_ID;
13061
    uint64_t var_idx = OB_INVALID_ID;
13062
    CK (OB_NOT_NULL(f_expr) && f_expr->get_param_count() >= 2);
13063
    GET_CONST_EXPR_VALUE(f_expr->get_param_expr(0), package_id);
13064
    GET_CONST_EXPR_VALUE(f_expr->get_param_expr(1), var_idx);
13065
    if (OB_SUCC(ret) && for_write) {
13066
      OZ (check_package_variable_read_only(package_id, var_idx));
13067
    }
13068
    OZ (check_package_accessible(current_block_, resolve_ctx_.schema_guard_, package_id));
13069
  } else if (expr->is_sys_func_expr()
13070
             && T_OP_GET_SUBPROGRAM_VAR == expr->get_expr_type()
13071
             && for_write) {
13072
    const ObSysFunRawExpr *f_expr = static_cast<const ObSysFunRawExpr *>(expr);
13073
    uint64_t subprogram_id = OB_INVALID_ID;
13074
    uint64_t var_idx = OB_INVALID_ID;
13075
    CK (OB_NOT_NULL(f_expr) && f_expr->get_param_count() >= 3);
13076
    GET_CONST_EXPR_VALUE(f_expr->get_param_expr(1), subprogram_id);
13077
    GET_CONST_EXPR_VALUE(f_expr->get_param_expr(2), var_idx);
13078
    OZ (check_subprogram_variable_read_only(
13079
      current_block_->get_namespace(), subprogram_id, var_idx));
13080
  }
13081

13082
#undef GET_CONST_EXPR_VALUE
13083

13084
  return ret;
13085
}
13086

13087
int ObPLResolver::resolve_var(ObQualifiedName &q_name, ObPLBlockNS &ns,
13088
                              ObRawExprFactory &expr_factory, const ObSQLSessionInfo *session_info,
13089
                              ObPLCompileUnitAST &func, ObRawExpr *&expr, bool for_write)
13090
{
13091
  int ret = OB_SUCCESS;
13092
  ObSEArray<ObObjAccessIdx, 8> access_idxs;
13093
  if (OB_FAIL(resolve_name(q_name, ns, expr_factory, session_info, access_idxs, func))) {
13094
    LOG_IN_CHECK_MODE("failed to resolve symbol", K(q_name), K(ret));
13095
    ret = (OB_ERR_SP_DOES_NOT_EXIST == ret
13096
            || OB_ERR_FUNCTION_UNKNOWN == ret
13097
            || OB_ERR_SP_WRONG_ARG_NUM == ret) ? OB_ERR_SP_UNDECLARED_VAR : ret;
13098
  } else if (!ObObjAccessIdx::is_local_variable(access_idxs)
13099
             && !ObObjAccessIdx::is_function_return_variable(access_idxs)
13100
             && !ObObjAccessIdx::is_package_variable(access_idxs)
13101
             && !ObObjAccessIdx::is_get_variable(access_idxs)
13102
             && !ObObjAccessIdx::is_subprogram_variable(access_idxs)) {
13103
    ret = OB_ERR_SP_UNDECLARED_VAR;
13104
    LOG_WARN("failed to resolve var", K(q_name), K(access_idxs));
13105
    LOG_USER_ERROR(OB_ERR_SP_UNDECLARED_VAR,
13106
                   access_idxs.at(access_idxs.count()-1).var_name_.length(),
13107
                   access_idxs.at(access_idxs.count()-1).var_name_.ptr());
13108
  } else if (OB_FAIL(check_variable_accessible(ns, access_idxs, for_write))) {
13109
    LOG_WARN("failed to check variable read only", K(ret), K(q_name), K(access_idxs));
13110
  } else if (OB_FAIL(make_var_from_access(access_idxs, expr_factory, session_info,
13111
                                          &resolve_ctx_.schema_guard_, ns, expr, for_write))) {
13112
    LOG_WARN("failed to make var from access", K(ret), K(q_name), K(access_idxs));
13113
  } else { /*do nothing*/ }
13114

13115
  if (OB_SUCC(ret)) {
13116
    if (ObObjAccessIdx::is_package_variable(access_idxs)) {
13117
      if (for_write) {
13118
        OX (func.set_wps());
13119
      } else {
13120
        OX (func.set_rps());
13121
      }
13122
    } else if (ObObjAccessIdx::is_get_variable(access_idxs)) {
13123
      OX (func.set_external_state());
13124
    }
13125
  }
13126
  return ret;
13127
}
13128

13129
int ObPLResolver::resolve_local_var(const ObString &var_name,
13130
                                    ObPLBlockNS &ns,
13131
                                    ObRawExprFactory &expr_factory,
13132
                                    const ObSQLSessionInfo *session_info,
13133
                                    ObSchemaGetterGuard *schema_guard,
13134
                                    ObRawExpr *&expr,
13135
                                    bool for_write)
13136
{
13137
  int ret = OB_SUCCESS;
13138
  uint64_t parent_id = OB_INVALID_INDEX;
13139
  int64_t var_index = OB_INVALID_INDEX;
13140
  ObPLExternalNS::ExternalType type = ObPLExternalNS::INVALID_VAR;
13141
  ObPLDataType pl_data_type;
13142
  ObObjAccessIdx access_idx;
13143
  if (OB_FAIL(ns.resolve_symbol(var_name, type, pl_data_type, parent_id, var_index))) {
13144
    LOG_WARN("failed to get var index", K(var_name), K(ret));
13145
  } else if (ObPLExternalNS::LOCAL_VAR != type) {
13146
    ret = OB_ERR_SP_UNDECLARED_VAR;
13147
    LOG_USER_ERROR(OB_ERR_SP_UNDECLARED_VAR, var_name.length(), var_name.ptr());
13148
  } else {
13149
    new(&access_idx)ObObjAccessIdx(pl_data_type,
13150
                                   static_cast<ObObjAccessIdx::AccessType>(type),
13151
                                   var_name,
13152
                                   pl_data_type,
13153
                                   var_index);
13154
  }
13155
  if (OB_SUCC(ret) && for_write) {
13156
    const ObPLVar *var = NULL;
13157
    const ObPLSymbolTable *symbol_table = NULL;
13158
    CK (OB_NOT_NULL(symbol_table))
13159
    CK (OB_NOT_NULL(var = symbol_table->get_symbol(var_index)));
13160
    if (OB_SUCC(ret) && var->is_readonly()) {
13161
      ret = OB_ERR_VARIABLE_IS_READONLY;
13162
      LOG_WARN("variable is read only", K(ret), K(access_idx));
13163
    }
13164
  }
13165
  if (OB_SUCC(ret)) {
13166
    ObSEArray<ObObjAccessIdx, 8> access_idxs;
13167
    if (OB_FAIL(access_idxs.push_back(access_idx))) {
13168
      LOG_WARN("failed to resolve symbol", K(var_name), K(ret));
13169
    } else if (OB_FAIL(make_var_from_access(access_idxs, expr_factory,
13170
                                            session_info, schema_guard,
13171
                                            ns, expr, for_write))) {
13172
      LOG_WARN("failed to make var from access", K(var_name));
13173
    } else { /*do nothing*/ }
13174
  }
13175
  return ret;
13176
}
13177

13178
int ObPLResolver::resolve_local_var(const ParseNode &node,
13179
                                    ObPLBlockNS &ns,
13180
                                    ObRawExprFactory &expr_factory,
13181
                                    const ObSQLSessionInfo *session_info,
13182
                                    ObSchemaGetterGuard *schema_guard,
13183
                                    ObRawExpr *&expr,
13184
                                    bool for_write)
13185
{
13186
  int ret = OB_SUCCESS;
13187
  if (OB_FAIL(resolve_local_var(ObString(node.str_len_, node.str_value_),
13188
                                ns, expr_factory, session_info,
13189
                                schema_guard, expr, for_write))) {
13190
    LOG_WARN("failed to resolve_local_var", K(ret));
13191
  }
13192
  return ret;
13193
}
13194

13195
int ObPLResolver::build_obj_access_func_name(const ObIArray<ObObjAccessIdx> &access_idxs,
13196
                                             ObRawExprFactory &expr_factory,
13197
                                             const ObSQLSessionInfo *session_info,
13198
                                             ObSchemaGetterGuard *schema_guard,
13199
                                             bool for_write,
13200
                                             ObString &result)
13201
{
13202
  int ret = OB_SUCCESS;
13203
  //函数名称格式为get_attr_idx_a
13204
  ObSqlString buf;
13205
  OZ (buf.append_fmt("%s", "get_attr"));
13206
  if (for_write /*&& ObObjAccessIdx::is_contain_object_type(access_idxs)*/) {
13207
    OZ (buf.append_fmt("%s", "_for_write"));
13208
  }
13209
  for (int64_t i = 0; OB_SUCC(ret) && i < access_idxs.count(); ++i) {
13210
    if (ObObjAccessIdx::IS_TYPE_METHOD == access_idxs.at(i).access_type_) {
13211
      continue;
13212
    } else if (!access_idxs.at(i).var_name_.empty()) {
13213
      OZ (buf.append_fmt("_var_name_%.*s",
13214
                          access_idxs.at(i).var_name_.length(),
13215
                          access_idxs.at(i).var_name_.ptr()),
13216
                          i, access_idxs);
13217
      if (OB_INVALID_INDEX != access_idxs.at(i).var_index_) {
13218
        //如果按名字编码需要把idx也编进去，防止出现同名的情况
13219
        OZ (buf.append_fmt("_%ld", access_idxs.at(i).var_index_),
13220
                           i, access_idxs);
13221
      }
13222
    } else if (OB_INVALID_INDEX != access_idxs.at(i).var_index_) {
13223
      OZ (buf.append_fmt("_var_index_%ld", access_idxs.at(i).var_index_),
13224
                         i, access_idxs);
13225
    } else if (NULL == access_idxs.at(i).get_sysfunc_) {
13226
      ret = OB_ERR_UNEXPECTED;
13227
      LOG_WARN("Cannot generate function name for Unexpected ObjAccess",
13228
               K(access_idxs), K(ret));
13229
    }
13230
    if (NULL != access_idxs.at(i).get_sysfunc_) {
13231
      OZ (buf.append_fmt("_get_sysfunc_"), K(i), K(access_idxs));
13232
      if (OB_SUCC(ret)) {
13233
        HEAP_VAR(char[OB_MAX_DEFAULT_VALUE_LENGTH], expr_str_buf) {
13234
          MEMSET(expr_str_buf, 0, sizeof(expr_str_buf));
13235
          int64_t pos = 0;
13236
          ObRawExprPrinter expr_printer(
13237
            expr_str_buf, OB_MAX_DEFAULT_VALUE_LENGTH, &pos, schema_guard, session_info->get_timezone_info());
13238
          OZ (expr_printer.do_print(access_idxs.at(i).get_sysfunc_, T_NONE_SCOPE, true));
13239
          OZ (buf.append_fmt("%.*s", static_cast<int32_t>(pos), expr_str_buf));
13240
        }
13241
        if (OB_SUCC(ret) && access_idxs.at(i).get_sysfunc_->is_udf_expr()) {
13242
          //如果是UDF需要把id也编进去，防止出现同名的情况
13243
          ObUDFRawExpr* udf_expr = static_cast<ObUDFRawExpr*>(access_idxs.at(i).get_sysfunc_);
13244
          OZ (buf.append_fmt("_%ld_%ld", udf_expr->get_pkg_id(), udf_expr->get_udf_id()),
13245
              i, access_idxs);
13246
          for (int64_t j = 0; OB_SUCC(ret) && j < udf_expr->get_subprogram_path().count(); ++j) {
13247
            OZ (buf.append_fmt("_%ld", udf_expr->get_subprogram_path().at(j)),
13248
                               i, j, access_idxs);
13249
          }
13250
        }
13251
      }
13252
    }
13253
  }
13254
  OZ (ob_write_string(expr_factory.get_allocator(), buf.string(), result));
13255
  return ret;
13256
}
13257

13258
int ObPLResolver::make_var_from_access(const ObIArray<ObObjAccessIdx> &access_idxs,
13259
                                       ObRawExprFactory &expr_factory,
13260
                                       const ObSQLSessionInfo *session_info,
13261
                                       ObSchemaGetterGuard *schema_guard,
13262
                                       const ObPLBlockNS &ns,
13263
                                       ObRawExpr *&expr,
13264
                                       bool for_write)
13265
{
13266
  int ret = OB_SUCCESS;
13267
  CK (!access_idxs.empty());
13268
  if (OB_FAIL(ret)) {
13269
  } else if (OB_LIKELY(ObObjAccessIdx::is_local_baisc_variable(access_idxs)
13270
      || ObObjAccessIdx::is_local_refcursor_variable(access_idxs))) {
13271
    ObConstRawExpr *c_expr = NULL;
13272
    ObExprResType res_type;
13273
    ObObjParam val;
13274
    int pos = access_idxs.count() - 1;
13275
    OZ (expr_factory.create_raw_expr(T_QUESTIONMARK, c_expr));
13276
    CK (OB_NOT_NULL(c_expr));
13277
    OX (val.set_unknown(access_idxs.at(pos).var_index_));
13278
    OX (c_expr->set_value(val));
13279
    if (OB_SUCC(ret)) {
13280
      if (ObObjAccessIdx::is_local_baisc_variable(access_idxs)) {
13281
        CK (OB_NOT_NULL(access_idxs.at(pos).elem_type_.get_data_type()));
13282
        OX (res_type.set_meta(access_idxs.at(pos).elem_type_.get_data_type()->get_meta_type()));
13283
        OX (res_type.set_accuracy(access_idxs.at(pos).elem_type_.get_data_type()->get_accuracy()));
13284
      } else {
13285
        OX (res_type.set_type(access_idxs.at(pos).elem_type_.get_obj_type()));
13286
        OX (res_type.set_udt_id(access_idxs.at(pos).elem_type_.get_user_type_id()));
13287
        OX (res_type.set_extend_type(access_idxs.at(pos).elem_type_.get_type()));
13288
      }
13289
    }
13290
    OX (c_expr->set_result_type(res_type));
13291
    OX (c_expr->set_enum_set_values(access_idxs.at(pos).elem_type_.get_type_info()));
13292
    OZ (c_expr->add_flag(IS_DYNAMIC_PARAM));
13293
    if (OB_SUCC(ret) && ob_is_enum_or_set_type(res_type.get_type())) {
13294
      c_expr->add_flag(IS_ENUM_OR_SET);
13295
    }
13296
    OZ (c_expr->extract_info());
13297
    OX (expr = c_expr);
13298
  } else if (ObObjAccessIdx::is_package_baisc_variable(access_idxs)
13299
             || ObObjAccessIdx::is_package_cursor_variable(access_idxs)
13300
             || ObObjAccessIdx::is_subprogram_basic_variable(access_idxs)
13301
             || ObObjAccessIdx::is_subprogram_cursor_variable(access_idxs)
13302
             || ObObjAccessIdx::is_get_variable(access_idxs)) {
13303
    CK (OB_NOT_NULL(expr = access_idxs.at(access_idxs.count() - 1).get_sysfunc_));
13304
    OZ (expr->formalize(session_info));
13305
    OZ (formalize_expr(*expr, session_info, ns), expr, access_idxs);
13306
  } else {
13307
    ObObjAccessRawExpr *obj_access_ref = NULL;
13308

13309
    OZ (expr_factory.create_raw_expr(T_OBJ_ACCESS_REF, obj_access_ref));
13310
    CK (OB_NOT_NULL(obj_access_ref));
13311
    OZ (obj_access_ref->add_access_indexs(access_idxs), K(access_idxs));
13312

13313
    OX (obj_access_ref->set_enum_set_values(access_idxs.at(access_idxs.count() - 1).elem_type_.get_type_info()));
13314
    OZ (set_write_property(obj_access_ref, expr_factory, session_info, schema_guard, for_write));
13315
    OZ (obj_access_ref->formalize(session_info));
13316
    OZ (formalize_expr(*obj_access_ref, session_info, ns));
13317
    OX (expr = obj_access_ref);
13318
  }
13319
  return ret;
13320
}
13321

13322
int ObPLResolver::resolve_name(ObQualifiedName &q_name,
13323
                               const ObPLBlockNS &ns,
13324
                               ObRawExprFactory &expr_factory,
13325
                               const ObSQLSessionInfo *session_info,
13326
                               ObIArray<ObObjAccessIdx> &access_idxs,
13327
                               ObPLCompileUnitAST &func)
13328
{
13329
  int ret = OB_SUCCESS;
13330
  if (OB_UNLIKELY(q_name.access_idents_.empty())) {
13331
    if (lib::is_oracle_mode()) {
13332
      ret = OB_ERR_UNEXPECTED;
13333
      LOG_WARN("qualified name is empty", K(ret));
13334
    } else { //mysql兼容性
13335
      if (!q_name.tbl_name_.empty()) {
13336
        ret = OB_ERR_UNKNOWN_TABLE;
13337
        LOG_USER_ERROR(OB_ERR_UNKNOWN_TABLE,
13338
                       static_cast<int32_t>(q_name.tbl_name_.length()), q_name.tbl_name_.ptr(),
13339
                       static_cast<int32_t>(q_name.database_name_.length()), q_name.database_name_.ptr());
13340
      } else {
13341
        ret = OB_ERR_BAD_FIELD_ERROR;
13342
        LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR,
13343
                       static_cast<int32_t>(q_name.col_name_.length()), q_name.col_name_.ptr(),
13344
                       static_cast<int32_t>(q_name.tbl_name_.length()), q_name.tbl_name_.ptr());
13345
      }
13346
    }
13347
  } else {
13348
    for (int64_t i = 0; OB_SUCC(ret) && i < q_name.access_idents_.count(); ++i) {
13349
      ObObjAccessIdent &access_ident = q_name.access_idents_.at(i);
13350
      if (OB_FAIL(resolve_access_ident(access_ident,
13351
                                       ns,
13352
                                       expr_factory,
13353
                                       session_info,
13354
                                       access_idxs,
13355
                                       func,
13356
                                       access_ident.is_pl_udf()))) {
13357
        LOG_IN_CHECK_MODE("failed to resolve access ident", K(ret), K(i), K(q_name.access_idents_));
13358
      }
13359
    }
13360
  }
13361
  return ret;
13362
}
13363

13364
// resolve external symbol direct
13365
int ObPLResolver::resolve_access_ident(const ObObjAccessIdent &access_ident,
13366
                                       ObPLExternalNS &external_ns,
13367
                                       ObIArray<ObObjAccessIdx> &access_idxs)
13368
{
13369
  int ret = OB_SUCCESS;
13370

13371
  SET_LOG_CHECK_MODE();
13372

13373
  ObObjAccessIdx access_idx;
13374
  uint64_t parent_id = OB_INVALID_INDEX;
13375
  int64_t var_index = OB_INVALID_INDEX;
13376
  ObPLExternalNS::ExternalType type = static_cast<ObPLExternalNS::ExternalType>(access_ident.access_index_);
13377
  ObPLDataType pl_data_type;
13378
  int64_t cnt = access_idxs.count();
13379
  if (0 == cnt // 当前为根节点
13380
      || ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 1).access_type_ // 父节点是DB Name
13381
      || ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_  // 父节点是Package Name
13382
      || ObObjAccessIdx::IS_TABLE_NS == access_idxs.at(cnt - 1).access_type_) {
13383
    if (cnt != 0) {
13384
      if (ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 1).access_type_) {
13385
        type = ObPLExternalNS::INVALID_VAR; // 父节点是DB Name, 子节点可能是Package Name或者Table Name
13386
      } else if (ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_) {
13387
        type = ObPLExternalNS::PKG_VAR; // 父节点是PackageName, 子节点尝试���析为Package Var
13388
      } else if (ObObjAccessIdx::IS_TABLE_NS == access_idxs.at(cnt - 1).access_type_) {
13389
        type = ObPLExternalNS::TABLE_COL; // 父节点是TableName, 子节点尝试解析为ColumnName
13390
      }
13391
      parent_id = access_idxs.at(cnt - 1).var_index_;
13392
    }
13393
    OZ (external_ns.resolve_external_symbol(access_ident.access_name_,
13394
                                            type,
13395
                                            pl_data_type,
13396
                                            parent_id,
13397
                                            var_index), K(access_ident));
13398
    if (ObPLExternalNS::INVALID_VAR == type) {
13399
      ret = OB_ERR_SP_UNDECLARED_VAR;
13400
      LOG_WARN("failed to resolve access ident",
13401
               K(ret), K(access_ident), K(access_idxs));
13402
    } else {
13403
      new(&access_idx)ObObjAccessIdx(pl_data_type,
13404
                                     static_cast<ObObjAccessIdx::AccessType>(type),
13405
                                     access_ident.access_name_,
13406
                                     pl_data_type,
13407
                                     var_index);
13408
    }
13409
    OZ (access_idxs.push_back(access_idx));
13410
  } else {
13411
    ret = OB_NOT_SUPPORTED;
13412
    LOG_WARN("not supported condition in resovle_access_ident",
13413
             K(ret), K(cnt), K(access_idxs.at(cnt - 1).access_type_));
13414
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "access type");
13415
  }
13416

13417
  CANCLE_LOG_CHECK_MODE();
13418

13419
  return ret;
13420
}
13421

13422
int ObPLResolver::check_is_udt_routine(const ObObjAccessIdent &access_ident, // 当前正在resolve的ident
13423
                                       const ObPLBlockNS &ns,
13424
                                       ObIArray<ObObjAccessIdx> &access_idxs,
13425
                                       bool &is_routine)
13426
{
13427
  int ret = OB_SUCCESS;
13428
  is_routine = false;
13429
  uint64_t udt_id = OB_INVALID_ID;
13430
  uint64_t cnt = access_idxs.count();
13431
  if (cnt > 0 && access_idxs.at(cnt - 1).elem_type_.is_object_type()) {
13432
    const ObPLDataType &parent_type = access_idxs.at(cnt - 1).elem_type_;
13433
    const ObUserDefinedType *user_type = NULL;
13434
    common::ObArray<ObRawExpr *> expr_params;
13435
    ObProcType proc_type = INVALID_PROC_TYPE;
13436
    bool is_exist = false;
13437
    ObString database_name;
13438
    ObString object_name;
13439
    ObString routine_name = access_ident.access_name_;
13440

13441
    OZ (ns.get_pl_data_type_by_id(parent_type.get_user_type_id(), user_type));
13442
    CK (OB_NOT_NULL(user_type));
13443
    CK (user_type->is_udt_type() && (user_type->is_record_type() || user_type->is_opaque_type()));
13444
    OZ (get_udt_database_name(resolve_ctx_.schema_guard_, parent_type.get_user_type_id(), database_name));
13445
    OX (object_name = user_type->get_name());
13446
    OZ (access_ident.extract_params(0, expr_params));
13447
    OZ (ns.check_routine_exists(database_name, object_name, routine_name, ROUTINE_FUNCTION_TYPE, is_exist, proc_type, udt_id));
13448
    OZ (!is_exist ? ns.check_routine_exists(database_name, object_name, routine_name, ROUTINE_PROCEDURE_TYPE, is_exist, proc_type, udt_id) : OB_SUCCESS);
13449
    OX (is_routine = is_exist);
13450
  }
13451
  return ret;
13452
}
13453

13454
int ObPLResolver::convert_pltype_to_restype(ObIAllocator &alloc,
13455
                                            const ObPLDataType &pl_type,
13456
                                            ObExprResType *&result_type)
13457
{
13458
  int ret = OB_SUCCESS;
13459
  result_type = static_cast<ObExprResType *>(alloc.alloc(sizeof(ObExprResType)));
13460
  const ObDataType *data_type = pl_type.get_data_type();
13461
  if (OB_ISNULL(result_type)) {
13462
    ret = OB_ALLOCATE_MEMORY_FAILED;
13463
    LOG_WARN("allocate memory failed", K(ret));
13464
  } else {
13465
    new (result_type) ObExprResType(alloc);
13466
    if (OB_ISNULL(data_type)) {
13467
      result_type->set_ext();
13468
      result_type->set_udt_id(pl_type.get_user_type_id());
13469
      result_type->set_extend_type(pl_type.get_type());
13470
    } else {
13471
      result_type->set_type(data_type->get_obj_type());
13472
      if (ob_is_string_tc(result_type->get_type())
13473
          || ob_is_raw_tc(result_type->get_type())) {
13474
        result_type->set_length(data_type->get_length());
13475
        result_type->set_length_semantics(data_type->get_length_semantics());
13476
        result_type->set_collation_type(data_type->get_collation_type());
13477
        result_type->set_collation_level(data_type->get_collation_level());
13478
      } else if (ob_is_number_tc(result_type->get_type()) ||
13479
                 ob_is_interval_tc(result_type->get_type())) {
13480
        result_type->set_precision(data_type->get_precision());
13481
        result_type->set_scale(data_type->get_scale());
13482
      } else if (ob_is_text_tc(result_type->get_type())
13483
                || ob_is_lob_tc(result_type->get_type())) {
13484
        result_type->set_length(data_type->get_length());
13485
        result_type->set_collation_type(data_type->get_collation_type());
13486
        result_type->set_collation_level(data_type->get_collation_level());
13487
        result_type->set_scale(data_type->get_scale());
13488
      }
13489
    }
13490
  }
13491
  return ret;
13492
}
13493

13494
int ObPLResolver::get_names_by_access_ident(ObObjAccessIdent &access_ident,
13495
                                            ObIArray<ObObjAccessIdx> &access_idxs,
13496
                                            ObString &database_name,
13497
                                            ObString &package_name,
13498
                                            ObString &routine_name)
13499
{
13500
  int ret = OB_SUCCESS;
13501
  int64_t cnt = access_idxs.count();
13502
  routine_name = access_ident.access_name_;
13503
  if (cnt <= 0) {
13504
    // do nothing ...
13505
  } else if (ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_
13506
             || ObObjAccessIdx::IS_UDT_NS == access_idxs.at(cnt - 1).access_type_
13507
             || ObObjAccessIdx::IS_LABEL_NS == access_idxs.at(cnt - 1).access_type_
13508
             || ObObjAccessIdx::IS_DBLINK_PKG_NS == access_idxs.at(cnt-1).access_type_) {
13509
    package_name = access_idxs.at(cnt - 1).var_name_;
13510
    if (cnt >= 2) {
13511
      OV (2 == cnt, OB_ERR_UNEXPECTED, K(cnt));
13512
      OV (ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 2).access_type_, OB_ERR_UNEXPECTED, K(access_idxs.at(cnt - 2)));
13513
      OX (database_name = access_idxs.at(cnt - 2).var_name_);
13514
    }
13515
  } else if (ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 1).access_type_) {
13516
    database_name = access_idxs.at(cnt - 1).var_name_;
13517
    OV (1 == cnt, OB_ERR_UNEXPECTED, K(cnt));
13518
  } else if (access_idxs.at(cnt - 1).var_type_.is_object_type()) {
13519
    OZ (get_udt_names(
13520
      resolve_ctx_.schema_guard_, access_idxs.at(cnt - 1).var_type_.get_user_type_id(), database_name, package_name));
13521
  } else {
13522
    ret = OB_ERR_FUNCTION_UNKNOWN;
13523
    LOG_WARN("unknow function invoke", K(ret), K(access_idxs), K(access_ident));
13524
  }
13525
  return ret;
13526
}
13527

13528
int ObPLResolver::construct_name(ObString &database_name,
13529
                                 ObString &package_name,
13530
                                 ObString &routine_name,
13531
                                 ObSqlString &object_name)
13532
{
13533
  int ret = OB_SUCCESS;
13534
  if (!database_name.empty()) {
13535
    OZ (object_name.append_fmt("%.*s.", database_name.length(), database_name.ptr()));
13536
  }
13537
  if (!package_name.empty()) {
13538
    OZ (object_name.append_fmt("%.*s.", package_name.length(), package_name.ptr()));
13539
  }
13540
  CK (!routine_name.empty());
13541
  OZ (object_name.append(routine_name));
13542
  return ret;
13543
}
13544

13545
int ObPLMockSelfArg::mock()
13546
{
13547
  int ret = OB_SUCCESS;
13548
  if (access_idxs_.count() > 0 && expr_params_.count() > 0) {
13549
    if (expr_params_.at(0)->get_expr_type() != T_SP_CPARAM) {
13550
      // for compatible, here only try deduce, if has error, will report at later logic.
13551
      IGNORE_RETURN expr_params_.at(0)->formalize(&session_info_);
13552
    }
13553
    if (expr_params_.at(0)->has_flag(IS_UDT_UDF_SELF_PARAM)) {
13554
      // already has self argument, do nothing ...
13555
    } else if (ObObjAccessIdx::IS_UDT_NS == access_idxs_.at(access_idxs_.count() - 1).access_type_
13556
        && expr_params_.at(0)->get_result_type().get_expr_udt_id()
13557
              == access_idxs_.at(access_idxs_.count() - 1).var_index_) {
13558
      expr_params_.at(0)->add_flag(IS_UDT_UDF_SELF_PARAM);
13559
      mocked_ = true;
13560
      mark_only_ = true;
13561
    } else if (access_idxs_.at(access_idxs_.count() - 1).elem_type_.is_composite_type()
13562
                && expr_params_.at(0)->get_result_type().get_expr_udt_id()
13563
                    == access_idxs_.at(access_idxs_.count() - 1).elem_type_.get_user_type_id()) {
13564
      ObConstRawExpr *null_expr = NULL;
13565
      OZ (expr_factory_.create_raw_expr(T_NULL, null_expr));
13566
      CK (OB_NOT_NULL(null_expr));
13567
      OZ (null_expr->add_flag(IS_UDT_UDF_SELF_PARAM));
13568
      OZ (expr_params_.push_back(null_expr));
13569
      OX (std::rotate(expr_params_.begin(), expr_params_.begin() + expr_params_.count() - 1, expr_params_.end()));
13570
      OX (mocked_ = true);
13571
    }
13572
  }
13573
  return ret;
13574
}
13575

13576
ObPLMockSelfArg::~ObPLMockSelfArg()
13577
{
13578
  int ret = OB_SUCCESS;
13579
  if (mocked_) {
13580
    if (mark_only_) {
13581
      if (OB_FAIL(expr_params_.at(0)->clear_flag(IS_UDT_UDF_SELF_PARAM))) {
13582
        LOG_WARN("failed to clear flag", K(ret));
13583
      }
13584
    } else {
13585
      std::rotate(expr_params_.begin(), expr_params_.begin() + 1, expr_params_.end());
13586
      if (!expr_params_.at(expr_params_.count() - 1)->has_flag(IS_UDT_UDF_SELF_PARAM)) {
13587
        LOG_ERROR("rotate failed", K(expr_params_));
13588
      }
13589
      expr_params_.pop_back();
13590
    }
13591
  }
13592
}
13593

13594
int ObPLResolver::resolve_routine(ObObjAccessIdent &access_ident,
13595
                                  const ObPLBlockNS &ns,
13596
                                  ObIArray<ObObjAccessIdx> &access_idxs,
13597
                                  ObPLCompileUnitAST &func)
13598
{
13599
  int ret = OB_SUCCESS;
13600

13601
  ObString database_name, package_name, routine_name;
13602
  const ObIRoutineInfo *routine_info = NULL;
13603
  ObSEArray<ObRawExpr*, 4> expr_params;
13604
  ObProcType routine_type = access_ident.is_pl_udf() ? STANDALONE_FUNCTION : STANDALONE_PROCEDURE;
13605
  bool is_dblink_pkg_ns = false;
13606
  if (access_idxs.count() > 0) {
13607
    is_dblink_pkg_ns = (ObObjAccessIdx::IS_DBLINK_PKG_NS == access_idxs.at(access_idxs.count()-1).access_type_);
13608
  }
13609
  OZ (get_names_by_access_ident(
13610
    access_ident, access_idxs, database_name, package_name, routine_name));
13611

13612
  if (access_ident.is_pl_udf()) {
13613
    OZ (ObRawExprUtils::rebuild_expr_params(access_ident.udf_info_, &expr_factory_, expr_params),
13614
      K(access_ident), K(access_idxs));
13615
  } else {
13616
    OZ (access_ident.extract_params(0, expr_params));
13617
  }
13618

13619
  if (database_name.empty() && package_name.empty() && 0 == routine_name.case_compare("RAISE_APPLICATION_ERROR")) {
13620
    ObObjAccessIdx access_idx;
13621
    if (expr_params.count() != 2 && expr_params.count() != 3) {
13622
      ret = OB_ERR_WRONG_TYPE_FOR_VAR;
13623
      LOG_WARN("PLS-00306: wrong number or types of arguments in call to 'RAISE_APPLICATION_ERROR'", K(ret));;
13624
      LOG_USER_ERROR(OB_ERR_WRONG_TYPE_FOR_VAR, routine_name.length(), routine_name.ptr());
13625
    } else {
13626
      ObPLDataType invalid_pl_data_type;
13627
      new(&access_idx)ObObjAccessIdx(invalid_pl_data_type,
13628
                                     ObObjAccessIdx::AccessType::IS_SYSTEM_PROC,
13629
                                     routine_name,
13630
                                     invalid_pl_data_type);
13631
      OZ (access_idxs.push_back(access_idx));
13632
    }
13633
  } else {
13634

13635
    {
13636
      ObPLMockSelfArg self(access_idxs, expr_params, expr_factory_, resolve_ctx_.session_info_);
13637
      OZ (self.mock());
13638
      if (!is_dblink_pkg_ns) {
13639
        OZ (ns.resolve_routine(resolve_ctx_,
13640
                              database_name,
13641
                              package_name,
13642
                              routine_name,
13643
                              expr_params,
13644
                              routine_type,
13645
                              routine_info));
13646
      } else {
13647
        OZ (ObPLResolver::resolve_dblink_routine_with_synonym(resolve_ctx_,
13648
                                static_cast<uint64_t>(access_idxs.at(access_idxs.count()-1).var_index_),
13649
                                routine_name, expr_params, routine_info));
13650
        OX (func.set_can_cached(false));
13651
      }
13652
    }
13653

13654
    if (OB_FAIL(ret)
13655
        && OB_ERR_UNEXPECTED != ret
13656
        && OB_ERR_SP_WRONG_ARG_NUM != ret
13657
        && OB_ERR_CALL_WRONG_ARG != ret
13658
        && OB_ERR_FUNC_DUP != ret
13659
        && OB_ERR_POSITIONAL_FOLLOW_NAME != ret
13660
        && OB_ALLOCATE_MEMORY_FAILED != ret) {
13661
      // Not A Routine, try compostie access again.
13662
      if (access_idxs.count() > 0
13663
          && (access_idxs.at(access_idxs.count() - 1)).elem_type_.is_composite_type()
13664
          && OB_FAIL(resolve_composite_access(access_ident, access_idxs, ns, func))) {
13665
        LOG_WARN("failed to access composite access", K(ret), K(access_ident), K(access_idxs));
13666
      }
13667
      if (OB_FAIL(ret) && OB_ERR_NOT_FUNC_NAME != ret) {
13668
        LOG_INFO("failed to resolve routine",
13669
          K(ret), K(database_name), K(package_name), K(routine_name), K(routine_type), K(access_ident), K(access_idxs));
13670
        ret = OB_ERR_FUNCTION_UNKNOWN;
13671
        ObSqlString object_name;
13672
        construct_name(database_name, package_name, routine_name, object_name);
13673
        LOG_USER_ERROR(OB_ERR_FUNCTION_UNKNOWN,
13674
                       access_ident.is_pl_udf() ? "FUNCTION" : "PROCEDURE",
13675
                       object_name.string().length(), object_name.string().ptr());
13676
      }
13677
    } else { // find A routine, resolve it.
13678
      CK (OB_NOT_NULL(routine_info));
13679
#ifdef OB_BUILD_ORACLE_PL
13680
      OZ (check_routine_callable(ns, access_idxs, expr_params, *routine_info));
13681
#endif
13682
      if (OB_FAIL(ret)) {
13683
      } else if (OB_NOT_NULL(routine_info->get_ret_info())) {
13684
        CK (access_ident.is_pl_udf());
13685
        OZ (resolve_function(access_ident, access_idxs, routine_info, func));
13686
      } else {
13687
        OZ (resolve_procedure(access_ident, access_idxs, routine_info, routine_type));
13688
      }
13689
    }
13690
  }
13691
  return ret;
13692
}
13693

13694
#ifdef OB_BUILD_ORACLE_PL
13695
int ObPLResolver::check_routine_callable(const ObPLBlockNS &ns,
13696
                                         ObIArray<ObObjAccessIdx> &access_idxs,
13697
                                         ObIArray<ObRawExpr*> &expr_params,
13698
                                         const ObIRoutineInfo &routine_info)
13699
{
13700
  int ret = OB_SUCCESS;
13701
  if (routine_info.is_udt_static_routine()) {
13702
    if (access_idxs.empty()) {
13703
      uint64_t udt_id = OB_INVALID_ID;
13704
      OZ (ObPLUDTObjectManager::check_routine_callable(ns, true, udt_id));
13705
    } else {
13706
      if (access_idxs.at(access_idxs.count() - 1).access_type_ != ObObjAccessIdx::IS_UDT_NS) {
13707
        ret = OB_ERR_INVOKE_STATIC_BY_INSTANCE;
13708
        LOG_WARN("invoke static udt function with instance", K(ret), K(access_idxs));
13709
        LOG_USER_ERROR(OB_ERR_INVOKE_STATIC_BY_INSTANCE);
13710
      }
13711
    }
13712
  } else if (routine_info.is_udt_routine()
13713
             && !routine_info.is_udt_static_routine()
13714
             && !routine_info.is_udt_cons()
13715
             && !access_idxs.empty()) {
13716
    if (ObObjAccessIdx::IS_UDT_NS == access_idxs.at(access_idxs.count() - 1).access_type_) {
13717
      if (expr_params.count() > 0
13718
          && expr_params.at(0)->get_result_type().get_udt_id()
13719
              == access_idxs.at(access_idxs.count() - 1).var_index_) {
13720
        if (OB_FAIL(expr_params.at(0)->clear_flag(IS_UDT_UDF_SELF_PARAM))) {
13721
          LOG_WARN("failed to clear flag", K(ret));
13722
        }
13723
      } else if (expr_params.count() > 0
13724
                 && expr_params.at(0)->get_result_type().is_xml_sql_type()
13725
                 && (T_OBJ_XML == access_idxs.at(access_idxs.count() - 1).var_index_)) {
13726
        // select 'head' || xmlparse(document '<a>123</a>').getclobval() into a from dual;
13727
        if (OB_FAIL(expr_params.at(0)->clear_flag(IS_UDT_UDF_SELF_PARAM))) {
13728
          LOG_WARN("failed to clear flag", K(ret));
13729
        }
13730
      } /*else if (expr_params.count() > 0
13731
                 && expr_params.at(0)->get_expr_type() == T_QUESTIONMARK) {
13732
        // do nothing ...
13733
      } */ else {
13734
        ret = OB_ERR_SP_WRONG_ARG_NUM;
13735
        LOG_WARN("Incorrect number of arguments", K(ret));
13736
      }
13737
    }
13738
  }
13739
  return ret;
13740
}
13741
#endif
13742

13743
int ObPLResolver::resolve_function(ObObjAccessIdent &access_ident,
13744
                                   ObIArray<ObObjAccessIdx> &access_idxs,
13745
                                   const ObIRoutineInfo *routine_info,
13746
                                   ObPLCompileUnitAST &func)
13747
{
13748
  int ret = OB_SUCCESS;
13749

13750
  ObPLDataType return_type;
13751
  ObObjAccessIdx access_idx;
13752
  CK (OB_NOT_NULL(routine_info));
13753
  CK (OB_NOT_NULL(routine_info->get_ret_info()));
13754
  if (OB_FAIL(ret)) {
13755
  } else if (routine_info->get_ret_info()->is_schema_routine_param()) {
13756
    const ObRoutineParam *iparam = static_cast<const ObRoutineParam*>(routine_info->get_ret_info());
13757
    CK (OB_NOT_NULL(iparam));
13758
    OZ (pl::ObPLDataType::transform_from_iparam(iparam,
13759
                                                resolve_ctx_.schema_guard_,
13760
                                                resolve_ctx_.session_info_,
13761
                                                resolve_ctx_.allocator_,
13762
                                                resolve_ctx_.sql_proxy_,
13763
                                                return_type));
13764
  } else {
13765
    OX (return_type = routine_info->get_ret_info()->get_pl_data_type());
13766
  }
13767
  if (OB_SUCC(ret)
13768
      && access_ident.udf_info_.ref_expr_->get_udf_id() == OB_INVALID_ID) {
13769
    OZ (get_names_by_access_ident(access_ident,
13770
                                  access_idxs,
13771
                                  access_ident.udf_info_.udf_database_,
13772
                                  access_ident.udf_info_.udf_package_,
13773
                                  access_ident.udf_info_.udf_name_));
13774
    OZ (resolve_udf_info(access_ident.udf_info_, access_idxs, func), K(access_ident));
13775
    if (OB_SUCC(ret)
13776
        && access_ident.udf_info_.is_new_keyword_used_
13777
        && !access_ident.udf_info_.is_udf_udt_cons()) {
13778
      ret = OB_ERR_PARSER_SYNTAX;
13779
      LOG_WARN("NEW key word is only allowed for constructors", K(ret), K(access_ident));
13780
    }
13781
  }
13782
  OX (new(&access_idx)ObObjAccessIdx(return_type,
13783
                                     ObObjAccessIdx::AccessType::IS_UDF_NS,
13784
                                     access_ident.udf_info_.udf_name_,
13785
                                     return_type,
13786
                                     reinterpret_cast<int64_t>(access_ident.udf_info_.ref_expr_)));
13787
  OZ (access_idxs.push_back(access_idx));
13788

13789
  if (OB_SUCC(ret) && access_ident.is_pl_udf()) {
13790
    OZ (build_return_access(access_ident, access_idxs, func));
13791
  }
13792
  return ret;
13793
}
13794

13795
int ObPLResolver::resolve_procedure(ObObjAccessIdent &access_ident,
13796
                                    ObIArray<ObObjAccessIdx> &access_idxs,
13797
                                    const ObIRoutineInfo *routine_info,
13798
                                    ObProcType routine_type)
13799
{
13800
  int ret = OB_SUCCESS;
13801
  ObObjAccessIdx access_idx;
13802
  ObObjAccessIdx::AccessType access_type;
13803
  ObPLDataType invalid_type;
13804
  switch (routine_type) {
13805
    case STANDALONE_PROCEDURE: {
13806
      access_type = ObObjAccessIdx::AccessType::IS_EXTERNAL_PROC;
13807
    } break;
13808
    case NESTED_PROCEDURE: {
13809
      access_type = ObObjAccessIdx::AccessType::IS_NESTED_PROC;
13810
    } break;
13811
    default: {
13812
      access_type = ObObjAccessIdx::AccessType::IS_INTERNAL_PROC;
13813
    } break;
13814
  }
13815
  CK (OB_NOT_NULL(routine_info));
13816
  OX (new (&access_idx) ObObjAccessIdx(invalid_type,
13817
                                       access_type,
13818
                                       access_ident.access_name_,
13819
                                       invalid_type,
13820
                                       reinterpret_cast<int64_t>(routine_info)));
13821
  OZ (access_idxs.push_back(access_idx));
13822
  return ret;
13823
}
13824

13825
int ObPLResolver::resolve_construct(ObObjAccessIdent &access_ident,
13826
                                    const ObPLBlockNS &ns,
13827
                                    ObIArray<ObObjAccessIdx> &access_idxs,
13828
                                    uint64_t user_type_id,
13829
                                    ObPLCompileUnitAST &func)
13830
{
13831
  int ret = OB_SUCCESS;
13832
  ObQualifiedName q_name;
13833
  ObRawExpr* expr = NULL;
13834
  const ObUserDefinedType *user_type = NULL;
13835
  ObObjAccessIdx access_idx;
13836
  OV (access_ident.is_pl_udf(), OB_ERR_UNEXPECTED, K(access_ident));
13837
  OZ (ns.get_pl_data_type_by_id(user_type_id, user_type));
13838
  CK (OB_NOT_NULL(user_type));
13839
  if (OB_FAIL(ret)) {
13840
  } else if (access_idxs.count() > 0) {
13841
    OZ (get_names_by_access_ident(access_ident,
13842
                                  access_idxs,
13843
                                  access_ident.udf_info_.udf_database_,
13844
                                  access_ident.udf_info_.udf_package_,
13845
                                  access_ident.udf_info_.udf_name_));
13846
    if (OB_SUCC(ret) &&
13847
        !access_ident.udf_info_.udf_database_.empty() &&
13848
        access_ident.udf_info_.udf_database_.case_compare(OB_SYS_DATABASE_NAME) != 0) {
13849
      OZ (q_name.access_idents_.push_back(access_ident.udf_info_.udf_database_));
13850
    }
13851
    if (OB_SUCC(ret) && !access_ident.udf_info_.udf_package_.empty()) {
13852
      OZ (q_name.access_idents_.push_back(access_ident.udf_info_.udf_package_));
13853
    }
13854
  } else {
13855
    access_ident.udf_info_.udf_name_ = user_type->get_name();
13856
  }
13857
  OZ (q_name.access_idents_.push_back(access_ident));
13858
  OZ (resolve_construct(q_name, access_ident.udf_info_, *user_type, expr));
13859
  CK (OB_NOT_NULL(expr));
13860
  OZ (func.add_expr(expr));
13861
  OX (new(&access_idx)ObObjAccessIdx(*user_type,
13862
                                     ObObjAccessIdx::AccessType::IS_UDF_NS,
13863
                                     access_ident.access_name_,
13864
                                     *user_type,
13865
                                     reinterpret_cast<int64_t>(expr)));
13866
  OZ (access_idxs.push_back(access_idx));
13867
  if (OB_SUCC(ret) && access_ident.is_pl_udf()) {
13868
    OZ (build_return_access(access_ident, access_idxs, func));
13869
  }
13870
  return ret;
13871
}
13872

13873
int ObPLResolver::resolve_self_element_access(ObObjAccessIdent &access_ident,
13874
                                              const ObPLBlockNS &ns,
13875
                                              ObIArray<ObObjAccessIdx> &access_idxs,
13876
                                              ObPLCompileUnitAST &func)
13877
{
13878
  int ret = OB_SUCCESS;
13879
  const ObPLBlockNS *udt_routine_ns = ns.get_udt_routine_ns();
13880

13881
  if (0 == access_idxs.count() // Element Access Without Prefix [SELF.]
13882
      && OB_NOT_NULL(udt_routine_ns) // In UDT Routine Namepspace
13883
      && OB_NOT_NULL(udt_routine_ns->get_symbol_table()->get_self_param())) {
13884

13885
    ObObjAccessIdx self_access_idx;
13886
    ObObjAccessIdx elem_access_idx;
13887

13888
    const ObUserDefinedType *self_user_type = NULL;
13889
    const ObPLVar *self_var = udt_routine_ns->get_symbol_table()->get_self_param();
13890
    ObPLDataType self_data_type = self_var->get_type();
13891
    int64_t self_index = udt_routine_ns->get_symbol_table()->get_self_param_idx();
13892
    uint64_t user_type_id = udt_routine_ns->get_package_id();
13893

13894
    // Construct A Self AccessIdx
13895
    new (&self_access_idx) ObObjAccessIdx(self_data_type,
13896
                                          udt_routine_ns == &ns
13897
                                            ? ObObjAccessIdx::AccessType::IS_LOCAL
13898
                                              : ObObjAccessIdx::AccessType::IS_SUBPROGRAM_VAR,
13899
                                          self_var->get_name(),
13900
                                          self_data_type,
13901
                                          self_index);
13902

13903
    if (self_access_idx.is_subprogram_var()) {
13904
      ObExprResType *result_type = NULL;
13905
      CK (OB_NOT_NULL(udt_routine_ns));
13906
      OZ (convert_pltype_to_restype(expr_factory_.get_allocator(), self_data_type, result_type));
13907
      OX (self_access_idx.var_ns_ = udt_routine_ns);
13908
      OZ (ObRawExprUtils::build_get_subprogram_var(expr_factory_,
13909
                                                   udt_routine_ns->get_package_id(),
13910
                                                   udt_routine_ns->get_routine_id(),
13911
                                                   self_index,
13912
                                                   result_type,
13913
                                                   self_access_idx.get_sysfunc_,
13914
                                                   &resolve_ctx_.session_info_));
13915
    }
13916
    OZ (ns.get_pl_data_type_by_id(self_data_type.get_user_type_id(), self_user_type));
13917
    CK (OB_NOT_NULL(self_user_type));
13918
    OZ (self_user_type->get_all_depended_user_type(resolve_ctx_, ns));
13919

13920
    // Resolve Self AccessIdx with AccessIdent
13921
    OZ (udt_routine_ns->find_sub_attr_by_name(*self_user_type,
13922
                                              access_ident,
13923
                                              resolve_ctx_.session_info_,
13924
                                              expr_factory_,
13925
                                              func,
13926
                                              elem_access_idx,
13927
                                              self_data_type,
13928
                                              user_type_id,
13929
                                              self_index));
13930
    OZ (access_idxs.push_back(self_access_idx));
13931
    OZ (access_idxs.push_back(elem_access_idx));
13932

13933
    if (OB_FAIL(ret)) {
13934
    } else if (elem_access_idx.elem_type_.is_composite_type() && !access_ident.params_.empty()) { //collection type
13935
      OZ (build_collection_access(access_ident, access_idxs, func));
13936
    } else if (elem_access_idx.elem_type_.is_obj_type() && !access_ident.params_.empty()) {
13937
      ret = OB_ERR_NO_FUNCTION_EXIST;
13938
      LOG_WARN("PLS-00222: no function with name 'string' exists in this scope", K(ret), K(access_ident));
13939
    }
13940
  } else {
13941
    ret = OB_ERR_SP_UNDECLARED_VAR;
13942
    LOG_IN_CHECK_MODE("undeclared var", K(access_ident), K(ret));
13943
    if (lib::is_mysql_mode() || !resolve_ctx_.is_check_mode_) {
13944
      LOG_USER_ERROR(OB_ERR_SP_UNDECLARED_VAR,
13945
                     access_ident.access_name_.length(), access_ident.access_name_.ptr());
13946
    }
13947
  }
13948
  return ret;
13949
}
13950

13951
int ObPLResolver::build_access_idx_sys_func(uint64_t parent_id, ObObjAccessIdx &access_idx)
13952
{
13953
  int ret = OB_SUCCESS;
13954
  if (access_idx.is_pkg() || access_idx.is_subprogram_var()) {
13955
    ObExprResType *result_type = NULL;
13956
    OZ (convert_pltype_to_restype(expr_factory_.get_allocator(), access_idx.elem_type_, result_type));
13957
    if (OB_FAIL(ret)) {
13958
    } else if (access_idx.is_pkg()) {
13959
      OZ (ObRawExprUtils::build_get_package_var(expr_factory_,
13960
                                                resolve_ctx_.schema_guard_,
13961
                                                parent_id,
13962
                                                access_idx.var_index_,
13963
                                                result_type,
13964
                                                access_idx.get_sysfunc_,
13965
                                                &resolve_ctx_.session_info_));
13966
    } else if (access_idx.is_subprogram_var()) {
13967
      const ObPLBlockNS *ns = reinterpret_cast<const ObPLBlockNS*>(parent_id);;
13968
      CK (OB_NOT_NULL(ns));
13969
      OX (access_idx.var_ns_ = ns);
13970
      OZ (ObRawExprUtils::build_get_subprogram_var(expr_factory_,
13971
                                                   ns->get_package_id(),
13972
                                                   ns->get_routine_id(),
13973
                                                   access_idx.var_index_,
13974
                                                   result_type,
13975
                                                   access_idx.get_sysfunc_,
13976
                                                   &resolve_ctx_.session_info_));
13977
    }
13978
  } else if (access_idx.is_user_var()) {
13979
    OZ (ObRawExprUtils::build_get_user_var(expr_factory_,
13980
                                           access_idx.var_name_,
13981
                                           access_idx.get_sysfunc_,
13982
                                           &resolve_ctx_.session_info_), K(access_idx));
13983
  } else if (access_idx.is_session_var()) {
13984
    OZ (ObRawExprUtils::build_get_sys_var(expr_factory_,
13985
                                          access_idx.var_name_,
13986
                                          ObObjAccessIdx::IS_GLOBAL == access_idx.access_type_
13987
                                            ? ObSetVar::SET_SCOPE_GLOBAL : ObSetVar::SET_SCOPE_SESSION,
13988
                                          access_idx.get_sysfunc_,
13989
                                          &resolve_ctx_.session_info_), K(access_idx));
13990
  }
13991
  return ret;
13992
}
13993

13994
int ObPLResolver::build_current_access_idx(uint64_t parent_id,
13995
                                           ObObjAccessIdx &access_idx,
13996
                                           ObObjAccessIdent &access_ident,
13997
                                           const ObPLBlockNS &ns,
13998
                                           ObIArray<ObObjAccessIdx> &access_idxs,
13999
                                           ObPLCompileUnitAST &func)
14000
{
14001
  int ret = OB_SUCCESS;
14002

14003
  OZ (build_access_idx_sys_func(parent_id, access_idx));
14004
  OZ (access_idxs.push_back(access_idx), K(access_idx));
14005
  if (OB_FAIL(ret)) {
14006
  } else if (access_idx.elem_type_.is_composite_type() && !access_ident.params_.empty()) { //collection type
14007
    OZ (build_collection_access(access_ident, access_idxs, func));
14008
  } else if (access_idx.elem_type_.is_obj_type() && !access_ident.params_.empty()) {
14009
    ret = OB_ERR_NO_FUNCTION_EXIST;
14010
    LOG_WARN("PLS-00222: no function with name 'string' exists in this scope",
14011
               K(ret), K(access_idx.access_type_), K(access_ident));
14012
  }
14013
  return ret;
14014
}
14015

14016
int ObPLResolver::build_collection_index_expr(ObObjAccessIdent &access_ident,
14017
                                              ObObjAccessIdx &access_idx,
14018
                                              const ObPLBlockNS &ns,
14019
                                              ObIArray<ObObjAccessIdx> &access_idxs,
14020
                                              const ObUserDefinedType &user_type,
14021
                                              ObPLCompileUnitAST &func)
14022
{
14023
  int ret = OB_SUCCESS;
14024
  if (!access_ident.params_.empty()
14025
      && user_type.is_associative_array_type()) {
14026
    ObObjAccessIdx index_access_idx;
14027
    // associate array 会构造一个额外的表达式。所以调用build函数。例如aa('a');
14028
    // 这里使用一个tmp,而不是传access_idx的原因是，
14029
    // build会改变它的类型为IS_EXPR，这里预期需要的类型是IS_PROPERTY，
14030
    // 否则的话，objaccess表达式获取的就是expr计算结果，没有collection地址了。
14031
    OZ (build_collection_attribute_access(expr_factory_,
14032
                                          &resolve_ctx_.session_info_,
14033
                                          ns,
14034
                                          func,
14035
                                          user_type,
14036
                                          access_idxs,
14037
                                          OB_INVALID_INDEX,
14038
                                          access_ident.params_.at(0).first, // parameter level
14039
                                          index_access_idx));
14040
    if (OB_SUCC(ret)) {
14041
      ObPLAssocIndexRawExpr *index_expr = static_cast<ObPLAssocIndexRawExpr *>(index_access_idx.get_sysfunc_);
14042
      CK (OB_NOT_NULL(index_expr));
14043
      OX (index_expr->set_out_of_range_set_err(false));
14044
      OX (access_idx.get_sysfunc_ = index_access_idx.get_sysfunc_);
14045
      if (OB_FAIL(ret)) {
14046
      } else if (0 == access_idx.var_name_.case_compare("PRIOR")) {
14047
        index_expr->set_parent_type(parent_expr_type::EXPR_PRIOR);
14048
      } else if (0 == access_idx.var_name_.case_compare("NEXT")) {
14049
        index_expr->set_parent_type(parent_expr_type::EXPR_NEXT);
14050
      } else if (0 == access_idx.var_name_.case_compare("EXISTS")) {
14051
        index_expr->set_parent_type(parent_expr_type::EXPR_EXISTS);
14052
      } else {
14053
        index_expr->set_parent_type(parent_expr_type::EXPR_UNKNOWN);
14054
      }
14055
    }
14056
  } else {
14057
    // 这里暂时不调用build，因为a(1)这种会被build优化掉，
14058
    // 没有param，get_attr的时候直接拿这个常量值，不符合next,prior的预期
14059
    for (int64_t i = 0; OB_SUCC(ret) && i < access_idx.type_method_params_.count(); ++i) {
14060
      uint64_t expr_idx = access_idx.type_method_params_.at(i);
14061
      OV (expr_idx >= 0 && expr_idx < func.get_exprs().count(),
14062
            OB_ERR_UNEXPECTED, K(expr_idx), K(func.get_exprs().count()));
14063
      OX (access_idx.get_sysfunc_ = func.get_expr(expr_idx));
14064
    }
14065
  }
14066
  return ret;
14067
}
14068

14069

14070
int ObPLResolver::resolve_composite_access(ObObjAccessIdent &access_ident,
14071
                                           ObIArray<ObObjAccessIdx> &access_idxs,
14072
                                           const ObPLBlockNS &ns,
14073
                                           ObPLCompileUnitAST &func)
14074
{
14075
  int ret = OB_SUCCESS;
14076

14077
  const ObPLDataType &parent_type = access_idxs.at(access_idxs.count() - 1).elem_type_;
14078
  const ObUserDefinedType *user_type = NULL;
14079
  ObObjAccessIdx access_idx;
14080
  ObPLDataType pl_data_type;
14081
  uint64_t parent_id;
14082
  int64_t var_index;
14083

14084
  if (!parent_type.is_composite_type()) {
14085
    ret = OB_ERR_OUT_OF_SCOPE;
14086
    LOG_WARN("PLS-00225: subprogram or cursor reference is out of scope", K(ret), K(parent_type), K(access_ident));
14087
  }
14088

14089
  OZ (ns.get_pl_data_type_by_id(parent_type.get_user_type_id(), user_type));
14090
  CK (OB_NOT_NULL(user_type));
14091
  OZ (user_type->get_all_depended_user_type(resolve_ctx_, ns));
14092

14093
  if (OB_FAIL(ret)) {
14094
  } else if (access_ident.access_name_.empty()) { // no element name, must be collection access.
14095
    OV (!access_ident.params_.empty(), OB_ERR_UNEXPECTED, K(access_ident), K(access_idxs));
14096
    OZ (build_collection_access(access_ident, access_idxs, func));
14097
  } else { // record element access
14098
    OZ (ns.find_sub_attr_by_name(*user_type,
14099
                                 access_ident,
14100
                                 resolve_ctx_.session_info_,
14101
                                 expr_factory_,
14102
                                 func,
14103
                                 access_idx,
14104
                                 pl_data_type,
14105
                                 parent_id,
14106
                                 var_index));
14107

14108
    OZ (build_access_idx_sys_func(parent_id, access_idx));
14109

14110
    if (OB_FAIL(ret)) {
14111
    } else if (0 == access_idx.var_name_.case_compare("NEXT")
14112
              || 0 == access_idx.var_name_.case_compare("PRIOR")
14113
              || 0 == access_idx.var_name_.case_compare("EXISTS")) {
14114

14115
      CK (access_idx.type_method_params_.count() <= 1); // parameter count must be 0 or 1
14116

14117
      OZ (build_collection_index_expr(access_ident, access_idx, ns, access_idxs, *user_type, func));
14118
    }
14119

14120
    OZ (access_idxs.push_back(access_idx));
14121

14122
    if (OB_SUCC(ret)
14123
        && !access_idx.is_property()
14124
        && !access_idx.is_type_method()
14125
        && !access_ident.params_.empty()) {
14126
      // second level collection access. "X(1)(2)", here continue resolve "(2)"
14127
      OZ (build_collection_access(access_ident, access_idxs, func));
14128
    }
14129
  }
14130
  return ret;
14131
}
14132

14133
int ObPLResolver::resolve_sys_func_access(ObObjAccessIdent &access_ident,
14134
                                          ObIArray<ObObjAccessIdx> &access_idxs,
14135
                                          const ObSQLSessionInfo *session_info,
14136
                                          const ObPLBlockNS &ns)
14137
{
14138
  int ret = OB_SUCCESS;
14139
  ObObjAccessIdx access_idx;
14140
  const ObUserDefinedType *user_type = NULL;
14141
  CK (OB_NOT_NULL(access_ident.sys_func_expr_));
14142
  if (OB_SUCC(ret)) {
14143
    if (access_ident.sys_func_expr_->get_result_type().get_type() == ObMaxType) {
14144
      if (OB_FAIL(access_ident.sys_func_expr_->formalize(session_info))) {
14145
        LOG_WARN("deduce type failed for sys func ident", K(ret));
14146
      }
14147
    }
14148
    if (OB_FAIL(ret)) {
14149
    } else if (!access_ident.sys_func_expr_->get_result_type().is_xml_sql_type()
14150
                && !(access_ident.sys_func_expr_->get_result_type().is_ext())) {
14151
      ret = OB_ERR_NOT_OBJ_REF;
14152
      LOG_WARN("unsupported sys func ident",
14153
        K(ret), K(access_ident), K(access_ident.sys_func_expr_->get_result_type()),
14154
        K(access_ident.sys_func_expr_->get_result_type().get_udt_id()));
14155
    } else { // only xmltype is supported
14156
      OZ (ns.get_pl_data_type_by_id(T_OBJ_XML, user_type));
14157
    }
14158
  }
14159
  CK (OB_NOT_NULL(user_type));
14160
  OX (new (&access_idx) ObObjAccessIdx(*user_type,
14161
                                        ObObjAccessIdx::AccessType::IS_UDF_NS,
14162
                                        access_ident.access_name_,
14163
                                        *user_type,
14164
                                        reinterpret_cast<int64_t>(access_ident.sys_func_expr_)));
14165
  OZ (access_idxs.push_back(access_idx));
14166
  return ret;
14167
}
14168

14169

14170
int ObPLResolver::resolve_access_ident(ObObjAccessIdent &access_ident, // 当前正在resolve的ident
14171
                                       const ObPLBlockNS &ns,
14172
                                       ObRawExprFactory &expr_factory,
14173
                                       const ObSQLSessionInfo *session_info,
14174
                                       ObIArray<ObObjAccessIdx> &access_idxs, // 已经resolve过的ident信息, 作为当前ident的父节点
14175
                                       ObPLCompileUnitAST &func,
14176
                                       bool is_routine,
14177
                                       bool is_resolve_rowtype)
14178
{
14179
  int ret = OB_SUCCESS;
14180

14181
  SET_LOG_CHECK_MODE();
14182

14183
  ObObjAccessIdx access_idx;
14184
  uint64_t parent_id = OB_INVALID_INDEX;
14185
  int64_t var_index = OB_INVALID_INDEX;
14186
  ObPLExternalNS::ExternalType type = static_cast<ObPLExternalNS::ExternalType>(access_ident.access_index_);
14187
  ObPLDataType pl_data_type;
14188
  int64_t cnt = access_idxs.count();
14189

14190
  if (!is_routine) {
14191
    OZ (check_is_udt_routine(access_ident, ns, access_idxs, is_routine));
14192
  }
14193

14194
  if (0 == cnt && access_ident.is_sys_func()) {
14195
    OZ (resolve_sys_func_access(access_ident, access_idxs, session_info, ns));
14196
  } else if (0 == cnt
14197
      || ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 1).access_type_
14198
      || ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_
14199
      || ObObjAccessIdx::IS_TABLE_NS == access_idxs.at(cnt - 1).access_type_
14200
      || ObObjAccessIdx::IS_LABEL_NS == access_idxs.at(cnt - 1).access_type_
14201
      || ObObjAccessIdx::IS_UDT_NS == access_idxs.at(cnt - 1).access_type_
14202
      || ObObjAccessIdx::IS_DBLINK_PKG_NS == access_idxs.at(cnt-1).access_type_
14203
      || is_routine) {
14204
    bool label_symbol = false;
14205
    if (cnt != 0) {
14206
      if (ObObjAccessIdx::IS_DB_NS == access_idxs.at(cnt - 1).access_type_) {
14207
        type = ObPLExternalNS::INVALID_VAR; // 父节点是DB Name, 子节点可能是Package Name或者Table Name
14208
      } else if (ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_) {
14209
        type = ObPLExternalNS::PKG_VAR; // 父节点是PackageName, 子节点尝试解析为Package Var
14210
      } else if (ObObjAccessIdx::IS_TABLE_NS == access_idxs.at(cnt - 1).access_type_ && !is_routine) {
14211
        type = ObPLExternalNS::TABLE_COL; // 父节点是TableName, 子节点尝试解析为ColumnName
14212
      } else if (ObObjAccessIdx::IS_LABEL_NS == access_idxs.at(cnt - 1).access_type_) {
14213
        label_symbol = true;
14214
      }
14215
      if (!label_symbol) {
14216
        parent_id = access_idxs.at(cnt - 1).var_index_;
14217
      }
14218
    }
14219
    if (label_symbol) {
14220
      OZ (ns.resolve_label_symbol(access_ident.access_name_,
14221
                                  type,
14222
                                  pl_data_type,
14223
                                  access_idxs.at(cnt - 1).label_ns_,
14224
                                  var_index), K(access_ident.access_name_));
14225
      OX (parent_id =
14226
        ObPLExternalNS::ExternalType::SUBPROGRAM_VAR == type
14227
          ? reinterpret_cast<uint64_t>(access_idxs.at(cnt - 1).label_ns_)
14228
            : access_idxs.at(cnt - 1).label_ns_->get_package_id());
14229
    } else if (0 != cnt
14230
               && ObObjAccessIdx::IS_DBLINK_PKG_NS == access_idxs.at(cnt-1).access_type_ && !is_routine) {
14231
      OZ (resolve_dblink_type_with_synonym(parent_id, access_ident.access_name_, func, pl_data_type));
14232
      OX (type = ObPLExternalNS::PKG_TYPE);
14233
      OX (var_index = pl_data_type.get_user_type_id());
14234
    } else {
14235
      if (access_ident.is_pl_var() && access_ident.access_name_.empty()) { // questionmark variable
14236
        const ObPLSymbolTable *sym_tbl = ns.get_symbol_table();
14237
        int64_t var_idx = access_ident.access_index_;
14238
        const ObPLVar *local_var = NULL;
14239
        CK (OB_NOT_NULL(sym_tbl));
14240
        if (OB_SUCC(ret) && var_idx >= 0 && var_idx < sym_tbl->get_count()) {
14241
          CK (OB_NOT_NULL(local_var = sym_tbl->get_symbol(var_idx)));
14242
          OX (pl_data_type = local_var->get_type());
14243
          OX (type = ObPLExternalNS::LOCAL_VAR);
14244
          OX (var_index = var_idx);
14245
        }
14246
      } else {
14247
        OZ (ns.resolve_symbol(access_ident.access_name_,
14248
                              type,
14249
                              pl_data_type,
14250
                              parent_id,
14251
                              var_index), K(access_ident));
14252
      }
14253
      if (OB_SUCC(ret) && is_resolve_rowtype && ObPLExternalNS::LOCAL_VAR == type) {
14254
        const ObPLSymbolTable &sym_table = func.get_symbol_table();
14255
        const ObPLVar *var = sym_table.get_symbol(var_index);
14256
        if (OB_NOT_NULL(var) && var->is_formal_param()) {
14257
          ret = OB_ERR_TYPE_DECL_ILLEGAL;
14258
          LOG_WARN("row type illegal, should not be formal parameter", K(ret), KPC(var), K(access_ident), K(var_index));
14259
          LOG_USER_ERROR(OB_ERR_TYPE_DECL_ILLEGAL, access_ident.access_name_.length(), access_ident.access_name_.ptr());
14260
        }
14261
      }
14262
    }
14263

14264
    if (OB_FAIL(ret)) {
14265
    } else if ((ObPLExternalNS::LOCAL_TYPE == type || ObPLExternalNS::PKG_TYPE == type || ObPLExternalNS::UDT_NS == type)
14266
                && (is_routine || (access_ident.has_brackets_))) {
14267
      OZ (resolve_construct(access_ident, ns, access_idxs, var_index, func),
14268
        K(is_routine), K(is_resolve_rowtype), K(type),
14269
        K(pl_data_type), K(var_index), K(access_ident), K(access_idxs));
14270
    } else if (ObPLExternalNS::INVALID_VAR == type
14271
               || (ObPLExternalNS::SELF_ATTRIBUTE == type)
14272
               || (ObPLExternalNS::LOCAL_VAR == type && is_routine)
14273
               || (ObPLExternalNS::TABLE_NS == type && is_routine)
14274
               || (ObPLExternalNS::LABEL_NS == type && is_routine)
14275
               || (ObPLExternalNS::DB_NS == type && is_routine)
14276
               || (ObPLExternalNS::DBLINK_PKG_NS == type && is_routine)) {
14277
      if (is_routine) {
14278
        OZ (resolve_routine(access_ident, ns, access_idxs, func),
14279
          K(access_ident), K(access_idxs));
14280
      } else { // [self.]element, user can access element without self prefix, handle it in here.
14281
        OZ (resolve_self_element_access(access_ident, ns, access_idxs, func),
14282
          K(access_ident), K(access_idxs));
14283
      }
14284
    } else { // current symbol resolve success!
14285
      ObObjAccessIdx access_idx;
14286
      new(&access_idx)ObObjAccessIdx(pl_data_type,
14287
                                     static_cast<ObObjAccessIdx::AccessType>(type),
14288
                                     access_ident.access_name_,
14289
                                     pl_data_type,
14290
                                     var_index);
14291
      if (ObPLExternalNS::PKG_VAR == type
14292
           && cnt > 0) {
14293
        if (ObObjAccessIdx::IS_PKG_NS == access_idxs.at(cnt - 1).access_type_
14294
            && access_ident.has_brackets_
14295
            && access_ident.params_.count() == 0) {
14296
          ObSqlString object_name;
14297
          ObString empty_str;
14298
          construct_name(empty_str, access_idxs.at(cnt - 1).var_name_, access_ident.access_name_, object_name);
14299
          ret = OB_ERR_NOT_FUNC_NAME;
14300
          LOG_USER_ERROR(OB_ERR_NOT_FUNC_NAME, object_name.string().length(), object_name.string().ptr());
14301
        }
14302

14303
      }
14304
      OZ (build_access_idx_sys_func(parent_id, access_idx));
14305
      OZ (access_idxs.push_back(access_idx), K(access_idx));
14306
      if (OB_FAIL(ret)) {
14307
      } else if (access_idx.elem_type_.is_composite_type() && !access_ident.params_.empty()) { //collection type
14308
        OZ (build_collection_access(access_ident, access_idxs, func));
14309
      } else if (access_idx.elem_type_.is_obj_type() && !access_ident.params_.empty()) {
14310
        ret = OB_ERR_NO_FUNCTION_EXIST;
14311
        LOG_WARN("PLS-00222: no function with name 'string' exists in this scope",
14312
                   K(ret), K(access_idx.access_type_), K(access_ident));
14313
      }
14314
    }
14315
  } else {
14316
    // not top node and parent not a namespace, it must be composite access. handle it here.
14317
    OZ (resolve_composite_access(access_ident, access_idxs, ns, func), K(access_ident), K(access_idxs));
14318
  }
14319

14320
  CANCLE_LOG_CHECK_MODE();
14321

14322
  return ret;
14323
}
14324

14325
int ObPLResolver::build_collection_attribute_access(ObRawExprFactory &expr_factory,
14326
                                                    const ObSQLSessionInfo *session_info,
14327
                                                    const ObPLBlockNS &ns,
14328
                                                    ObPLCompileUnitAST &func,
14329
                                                    const ObUserDefinedType &user_type,
14330
                                                    ObIArray<ObObjAccessIdx> &access_idxs,
14331
                                                    int64_t attr_index,
14332
                                                    ObRawExpr *func_expr,
14333
                                                    ObObjAccessIdx &access_idx)
14334
{
14335
  int ret = OB_SUCCESS;
14336
#ifndef OB_BUILD_ORACLE_PL
14337
  UNUSEDx(expr_factory, session_info, ns, func, user_type, access_idxs, attr_index, func_expr, access_idx);
14338
#else
14339
  if (user_type.is_nested_table_type() || user_type.is_varray_type()) {
14340
    const ObCollectionType &table_type = static_cast<const ObCollectionType &>(user_type);
14341
    ObString empty_name;
14342
    new(&access_idx)ObObjAccessIdx(table_type.get_element_type(),
14343
                                   NULL == func_expr ?
14344
                                   ObObjAccessIdx::AccessType::IS_CONST : ObObjAccessIdx::AccessType::IS_EXPR,
14345
                                   empty_name,
14346
                                   table_type.get_element_type(),
14347
                                   NULL == func_expr ? attr_index : reinterpret_cast<int64_t>(func_expr));
14348
    if (NULL != func_expr && func_expr->is_const_raw_expr()) {
14349
      //如果是NestedTable，且括号里的参数是Const，那么不把这个Const作为param_expr处理，这是一个优化
14350
      const ObConstRawExpr* const_expr = static_cast<const ObConstRawExpr*>(func_expr);
14351
      CK (OB_NOT_NULL(const_expr));
14352
      if (OB_FAIL(ret)) {
14353
      } else if (func_expr->get_expr_type() != T_QUESTIONMARK) {
14354
        const ObObj &const_obj = const_expr->get_value();
14355
        int64_t var_index = OB_INVALID_INDEX;
14356
        if (const_obj.is_integer_type()) {
14357
          var_index = const_obj.get_int();
14358
        } else if (const_obj.is_number()) {
14359
          int64_t int_value  = OB_INVALID_INDEX;
14360
          if (!const_obj.get_number().is_valid_int64(int_value)) {
14361
            number::ObNumber number = const_obj.get_number();
14362
            if (OB_FAIL(number.round(0))) {
14363
              LOG_WARN("failed to round number value", K(ret), K(number));
14364
            } else if (!number.is_valid_int64(int_value)) {
14365
              ret = OB_ARRAY_OUT_OF_RANGE;
14366
              LOG_WARN("invalid const type for array index", K(const_obj), K(ret));
14367
            } else {
14368
              var_index = int_value;
14369
            }
14370
          } else {
14371
            var_index = int_value;
14372
          }
14373
        }
14374
        if (OB_SUCC(ret) && var_index > 0) {
14375
          access_idx.access_type_ = ObObjAccessIdx::AccessType::IS_CONST;
14376
          access_idx.var_index_  = var_index;
14377
          access_idx.get_sysfunc_ = NULL;
14378
        }
14379
      } else {
14380
        const ObPLVar *var = NULL;
14381
        CK (OB_NOT_NULL(ns.get_symbol_table()));
14382
        CK (OB_NOT_NULL(var = ns.get_symbol_table()->get_symbol(const_expr->get_value().get_unknown())));
14383
        if (OB_SUCC(ret)
14384
            && (ob_is_int_tc(var->get_type().get_obj_type())
14385
                || ob_is_uint_tc(var->get_type().get_obj_type())
14386
                || ob_is_number_tc(var->get_type().get_obj_type()))) {
14387
          access_idx.access_type_ = ObObjAccessIdx::AccessType::IS_LOCAL;
14388
          access_idx.var_index_ = const_expr->get_value().get_unknown();
14389
          access_idx.var_name_ = ns.get_symbol_table()->get_symbol(access_idx.var_index_)->get_name();
14390
        }
14391
      }
14392
    }
14393
    if (OB_SUCC(ret) && OB_NOT_NULL(access_idx.get_sysfunc_)) {
14394
      OZ (formalize_expr(*(access_idx.get_sysfunc_)));
14395
      if (OB_FAIL(ret)) {
14396
      } else if (access_idx.get_sysfunc_->get_result_type().is_ext()) {
14397
        ret = OB_ERR_EXPRESSION_WRONG_TYPE;
14398
        LOG_WARN("PLS-00382: expression is of wrong type",
14399
                 K(ret), K(access_idx.get_sysfunc_->get_result_type()));
14400
      } else {
14401
        OZ (ObRawExprUtils::build_column_conv_expr(
14402
        &resolve_ctx_.session_info_,
14403
        expr_factory_,
14404
        ObInt32Type,
14405
        CS_TYPE_INVALID,
14406
        (ObAccuracy::DDL_DEFAULT_ACCURACY2[lib::is_oracle_mode()][ObInt32Type]).accuracy_,
14407
        true,
14408
        NULL, /*"db_name."tb_name"."col_name"*/
14409
        NULL,
14410
        access_idx.get_sysfunc_,
14411
        true/*+is_in_pl*/));
14412
        CK (OB_NOT_NULL(access_idx.get_sysfunc_));
14413
        OZ (formalize_expr(*(access_idx.get_sysfunc_)));
14414
      }
14415
    }
14416
  } else if (user_type.is_associative_array_type()) {
14417
    const ObAssocArrayType &assoc_type = static_cast<const ObAssocArrayType&>(user_type);
14418
    ObPLAssocIndexRawExpr *result_expr = NULL;
14419
    if (OB_FAIL(expr_factory.create_raw_expr(T_FUN_PL_ASSOCIATIVE_INDEX, result_expr))) {
14420
      LOG_WARN("create ObOpRawExpr failed", K(ret));
14421
    } else if (OB_ISNULL(result_expr)) {
14422
      ret = OB_ALLOCATE_MEMORY_FAILED;
14423
      LOG_WARN("allocate memory failed", K(ret));
14424
    } else {
14425
      ObRawExpr *collection_expr = NULL;
14426
      if (OB_FAIL(make_var_from_access(access_idxs, expr_factory, session_info,
14427
                                       &resolve_ctx_.schema_guard_, ns, collection_expr))) {
14428
        LOG_WARN("failed to make var from access", K(access_idxs), K(ret));
14429
      } else if (OB_ISNULL(collection_expr)) {
14430
        ret = OB_ERR_UNEXPECTED;
14431
        LOG_WARN("failed to make_var_from_access", K(user_type), K(access_idxs), K(ret));
14432
      } else if (!collection_expr->is_obj_access_expr()) {
14433
        ret = OB_ERR_UNEXPECTED;
14434
        LOG_WARN("invalid collection expr", K(*collection_expr), K(user_type), K(access_idxs), K(ret));
14435
      } else if (OB_FAIL(func.add_obj_access_expr(collection_expr))) {
14436
        LOG_WARN("push back error", K(*collection_expr));
14437
      } else if (OB_FAIL(result_expr->add_param_expr(collection_expr))) {
14438
        LOG_WARN("failed to add param expr", K(ret));
14439
      } else {
14440
        ObRawExpr *key_expr = NULL;
14441
        int64_t idx_value  = OB_INVALID_INDEX;
14442
        if (NULL == func_expr) {
14443
          idx_value = attr_index;
14444
        } else if (func_expr->is_const_raw_expr()) {
14445
          const ObObj &const_obj = static_cast<const ObConstRawExpr*>(func_expr)->get_value();
14446
          if (const_obj.is_integer_type()) {
14447
            idx_value = const_obj.get_int();
14448
          } else if (const_obj.is_number()) {
14449
            if (!const_obj.get_number().is_valid_int64(idx_value)) {
14450
              idx_value  = OB_INVALID_INDEX;
14451
            }
14452
          } else { /*do nothing*/ }
14453
        } else { /*do nothing*/ }
14454

14455
        if (OB_SUCC(ret)) {
14456
          if (OB_INVALID_INDEX == idx_value) {
14457
            key_expr = func_expr;
14458
          } else {
14459
            ObConstRawExpr *const_expr = NULL;
14460
            if (OB_FAIL(ObRawExprUtils::build_const_int_expr(expr_factory, ObIntType, idx_value, const_expr))) {
14461
              LOG_WARN("failed to build_const_int_expr", K(ret));
14462
            } else {
14463
              key_expr = const_expr;
14464
            }
14465
          }
14466
          if (OB_SUCC(ret)) {
14467
            CK (OB_NOT_NULL(key_expr));
14468
            CK (OB_NOT_NULL(assoc_type.get_index_type().get_data_type()));
14469
            CK (OB_NOT_NULL(assoc_type.get_index_type().get_meta_type()));
14470
            if (OB_FAIL(ret)) {
14471
            } else if (OB_FAIL(key_expr->formalize(&(resolve_ctx_.session_info_)))) {
14472
              LOG_WARN("failed to formalize key expr", K(ret), KPC(key_expr));
14473
            } else if (T_NULL == key_expr->get_expr_type()) {
14474
              // do nothing
14475
            } else if (key_expr->get_result_type().get_obj_meta()
14476
                          == *assoc_type.get_index_type().get_meta_type()
14477
                       && key_expr->get_result_type().get_accuracy()
14478
                          == assoc_type.get_index_type().get_data_type()->get_accuracy()) {
14479
              //do nothing
14480
            } else if (key_expr->get_result_type().get_obj_meta()
14481
                          == *assoc_type.get_index_type().get_meta_type()
14482
                       && assoc_type.get_index_type().get_meta_type()->is_integer_type()) {
14483
              //如果是integer类型，不做类型转换，只检查值域
14484
              if (lib::is_oracle_mode()
14485
                  && assoc_type.get_index_type().is_pl_integer_type()
14486
                  && is_need_add_checker(
14487
                      assoc_type.get_index_type().get_pl_integer_type(),
14488
                      key_expr)
14489
                  && OB_FAIL(add_pl_integer_checker_expr(
14490
                            expr_factory_,
14491
                            PL_SIMPLE_INTEGER == assoc_type.get_index_type().get_pl_integer_type()
14492
                              ? PL_PLS_INTEGER : assoc_type.get_index_type().get_pl_integer_type(),
14493
                            assoc_type.get_index_type().get_lower(),
14494
                            assoc_type.get_index_type().get_upper(),
14495
                            key_expr))) {
14496
                LOG_WARN("failed to add pl integer checker expr", K(ret), KPC(key_expr));
14497
              } else if (OB_FAIL(key_expr->formalize(&(resolve_ctx_.session_info_)))) {
14498
                LOG_WARN("failed to formalize expr", K(ret));
14499
              }
14500
            } else if (!cast_supported(key_expr->get_result_type().get_type(),
14501
                          key_expr->get_result_type().get_collation_type(),
14502
                          assoc_type.get_index_type().get_data_type()->get_obj_type(),
14503
                          assoc_type.get_index_type().get_data_type()->get_collation_type())) {
14504
              ret = OB_ERR_INVALID_TYPE_FOR_OP;
14505
              LOG_WARN("transition does not support",
14506
                       K(ret),
14507
                       K(key_expr->get_result_type()),
14508
                       K(ob_obj_type_str(assoc_type.get_index_type().get_obj_type())),
14509
                       KPC(key_expr));
14510
            } else {
14511
              if (OB_FAIL(ObRawExprUtils::build_column_conv_expr(
14512
                          &resolve_ctx_.session_info_,
14513
                          expr_factory_,
14514
                          assoc_type.get_index_type().get_obj_type(),
14515
                          assoc_type.get_index_type().get_data_type()->get_collation_type(),
14516
                          assoc_type.get_index_type().get_data_type()->get_accuracy_value(),
14517
                          true,
14518
                          NULL, /*"db_name"."tb_name"."col_name"*/
14519
                          &assoc_type.get_index_type().get_type_info(),
14520
                          key_expr,
14521
                          true /*is_in_pl*/))) {
14522
                LOG_WARN("fail to build column conv expr", K(ret));
14523
              } else if (lib::is_oracle_mode()
14524
                        && assoc_type.get_index_type().is_pl_integer_type()
14525
                        && OB_FAIL(add_pl_integer_checker_expr(
14526
                                                expr_factory_,
14527
                                                assoc_type.get_index_type().get_pl_integer_type(),
14528
                                                assoc_type.get_index_type().get_lower(),
14529
                                                assoc_type.get_index_type().get_upper(),
14530
                                                key_expr))) {
14531
                LOG_WARN("failed to add pl integer checker expr", K(ret));
14532
              } else if (OB_FAIL(key_expr->formalize(&(resolve_ctx_.session_info_)))) {
14533
                LOG_WARN("failed to formalize expr", K(ret));
14534
              } else { /*do nothing*/ }
14535
            }
14536
          }
14537
        }
14538

14539
        if (OB_SUCC(ret)) {
14540
          if (OB_FAIL(result_expr->add_param_expr(key_expr))) {
14541
            LOG_WARN("failed to add param expr", K(ret));
14542
          } else if (assoc_type.get_index_type().get_meta_type()->is_string_type()) {
14543
            result_expr->set_is_index_by_varchar(true);
14544
          }
14545
        }
14546
      }
14547
    }
14548
    if (OB_SUCC(ret)) {
14549
      ObString empty_name;
14550
      new(&access_idx)ObObjAccessIdx(assoc_type.get_element_type(),
14551
                                     ObObjAccessIdx::AccessType::IS_EXPR,
14552
                                     empty_name,
14553
                                     assoc_type.get_element_type(),
14554
                                     reinterpret_cast<int64_t>(result_expr));
14555
      access_idx.var_index_ = attr_index;
14556
    }
14557
  } else {
14558
    ret = OB_ERR_UNEXPECTED;
14559
    LOG_WARN("Invalid user type", K(user_type), K(ret));
14560
  }
14561
#endif
14562
  return ret;
14563
}
14564

14565
int ObPLResolver::build_collection_access(ObObjAccessIdent &access_ident,
14566
                                        ObIArray<ObObjAccessIdx> &access_idxs,
14567
                                        ObPLCompileUnitAST &func,
14568
                                        int64_t start_level)
14569
{
14570
  int ret = OB_SUCCESS;
14571
#ifndef OB_BUILD_ORACLE_PL
14572
  UNUSEDx(access_ident, access_idxs, func, start_level);
14573
#else
14574
  CK (OB_NOT_NULL(current_block_));
14575
  if (OB_SUCC(ret)) {
14576
    const ObSQLSessionInfo &session_info = resolve_ctx_.session_info_;
14577
    ObPLBlockNS &ns = current_block_->get_namespace();
14578
    ObObjAccessIdx access_idx;
14579
    ObPLDataType parent_type;
14580
    int64_t param_level = start_level - 1;
14581
    OX (parent_type = ObObjAccessIdx::get_final_type(access_idxs));
14582
    for (int64_t i = 0; OB_SUCC(ret) && i < access_ident.params_.count(); ++i) {
14583
      if (access_ident.params_.at(i).second >= start_level) {
14584
        if (param_level == access_ident.params_.at(i).second) {
14585
          ret = OB_ERR_UNEXPECTED;
14586
          LOG_WARN("cannot access Collection by more than 1 index", K(access_ident), K(ret));
14587
        } else if (!parent_type.is_collection_type()) {
14588
          ret = OB_ERR_PL_COMMON;
14589
          LOG_WARN("cannot access non collection with parameter", K(ret));
14590
          LOG_USER_ERROR(OB_ERR_PL_COMMON, "can not access non collection with paremeter");
14591
        } else {
14592
          CK (param_level + 1 == access_ident.params_.at(i).second);
14593
          if (OB_SUCC(ret)) {
14594
            param_level = access_ident.params_.at(i).second;
14595
            const ObUserDefinedType *user_type = NULL;
14596
            OZ (ns.get_user_type(parent_type.get_user_type_id(), user_type));
14597
            CK (OB_NOT_NULL(user_type));
14598
            OZ (user_type->get_all_depended_user_type(resolve_ctx_, ns));
14599
            OX (parent_type = static_cast<const ObCollectionType*>(user_type)->get_element_type());
14600
            OZ (build_collection_attribute_access(expr_factory_,
14601
                                                          &session_info,
14602
                                                          ns,
14603
                                                          func,
14604
                                                          *user_type,
14605
                                                          access_idxs,
14606
                                                          OB_INVALID_INDEX,
14607
                                                          access_ident.params_.at(i).first,
14608
                                                          access_idx));
14609
            OZ (access_idxs.push_back(access_idx));
14610
          }
14611
        }
14612
      }
14613
    }
14614
  }
14615
#endif
14616
  return ret;
14617
}
14618

14619
int ObPLResolver::build_return_access(ObObjAccessIdent &access_ident,
14620
                                          ObIArray<ObObjAccessIdx> &access_idxs,
14621
                                          ObPLCompileUnitAST &func)
14622
{
14623
  return build_collection_access(access_ident, access_idxs, func, 1/*start level = 1*/);
14624
}
14625

14626
int ObPLResolver::resolve_into(const ParseNode *into_node, ObPLInto &into, ObPLFunctionAST &func)
14627
{
14628
  int ret = OB_SUCCESS;
14629
  CK (OB_NOT_NULL(into_node));
14630
  CK (OB_NOT_NULL(current_block_));
14631
  CK (OB_LIKELY(T_INTO_VARIABLES == into_node->type_));
14632
  CK (OB_LIKELY(1 == into_node->num_child_));
14633
  CK (OB_NOT_NULL(into_node->children_[0]));
14634
  CK (OB_LIKELY(T_SP_INTO_LIST == into_node->children_[0]->type_));
14635
  if (OB_SUCC(ret)) {
14636
    const ParseNode *into_list = into_node->children_[0];
14637
    for (int64_t i = 0; OB_SUCC(ret) && i < into_list->num_child_; ++i) {
14638
      ObQualifiedName q_name;
14639
      ObRawExpr* expr = NULL;
14640
      CK (OB_NOT_NULL(into_list->children_[i]))
14641
      if (OB_FAIL(ret)) {
14642
      } else if (T_SP_OBJ_ACCESS_REF == into_list->children_[i]->type_/*Oracle mode*/) {
14643
        OZ (resolve_obj_access_idents(*into_list->children_[i], q_name.access_idents_, func));
14644
      } else if (T_QUESTIONMARK == into_list->children_[i]->type_ /*Oracle mode*/) {
14645
        OZ (resolve_question_mark_node(into_list->children_[i], expr));
14646
        CK (OB_NOT_NULL(expr));
14647
      } else { /*Mysql mode*/
14648
        OZ (ObResolverUtils::resolve_obj_access_ref_node(expr_factory_,
14649
                                into_list->children_[i], q_name, resolve_ctx_.session_info_));
14650
      }
14651
      if (OB_SUCC(ret) && OB_ISNULL(expr)) {
14652
        OZ (resolve_var(q_name, func, expr, true/*fo write*/));
14653
      }
14654
      if (OB_ERR_VARIABLE_IS_READONLY == ret) {
14655
        ret = OB_ERR_EXP_NOT_INTO_TARGET;
14656
        LOG_USER_ERROR(OB_ERR_EXP_NOT_INTO_TARGET,
14657
                       static_cast<int>(into_list->children_[i]->str_len_),
14658
                       into_list->children_[i]->str_value_);
14659
      }
14660
      if (OB_SUCC(ret) && 1 == into_node->value_) {
14661
        into.set_bulk();
14662
      }
14663
      CK (OB_NOT_NULL(expr));
14664
      OZ (func.add_expr(expr));
14665
      OZ (into.add_into(func.get_expr_count() - 1, current_block_->get_namespace(), *expr));
14666
      if (OB_FAIL(ret)) {
14667
      } else if (expr->is_obj_access_expr()) {
14668
        OZ (func.add_obj_access_expr(expr));
14669
      } else if (T_OP_GET_PACKAGE_VAR == expr->get_expr_type()) {
14670
        OX (func.set_wps());
14671
      }
14672
    }
14673

14674
    // 检查[bulk] into var的var合法性，var不能是collection
14675
    OZ (into.check_into(func, current_block_->get_namespace(), 1 == into_node->value_));
14676
  }
14677
  return ret;
14678
}
14679

14680
struct ObPredefinedException {
14681
  ObPredefinedException(const char* name, ObPLConditionValue value) :
14682
    name_(name), value_(value) {}
14683
  const char* name_;
14684
  ObPLConditionValue value_;
14685
};
14686

14687
#define DEFINED_EXCEPTION(name, code) \
14688
  ObPredefinedException(name, ObPLConditionValue(ERROR_CODE, code))
14689

14690
static ObPredefinedException PREDEFINED_EXCEPTIONS[] =
14691
{
14692
  DEFINED_EXCEPTION("ACCESS_INTO_NULL", OB_ERR_ACCESS_INTO_NULL), // ORA-6530
14693
  DEFINED_EXCEPTION("CASE_NOT_FOUND", OB_ER_SP_CASE_NOT_FOUND), // ORA-6592
14694
  DEFINED_EXCEPTION("COLLECTION_IS_NULL", OB_ERR_COLLECION_NULL), // ORA-6531
14695
  DEFINED_EXCEPTION("CURSOR_ALREADY_OPEN", OB_ER_SP_CURSOR_ALREADY_OPEN), // ORA-6511
14696
  DEFINED_EXCEPTION("DUP_VAL_ON_INDEX", OB_ERR_PRIMARY_KEY_DUPLICATE), // ORA-1
14697

14698
  DEFINED_EXCEPTION("INVALID_CURSOR", OB_ERR_INVALID_CURSOR), // ORA-1001
14699
  DEFINED_EXCEPTION("INVALID_NUMBER", OB_INVALID_NUMERIC), // ORA-1722
14700
  DEFINED_EXCEPTION("LOGIN_DENIED", OB_ERR_LOGIN_DENIED), // ORA-1017
14701
  DEFINED_EXCEPTION("NO_DATA_FOUND", OB_READ_NOTHING), // ORA-+100
14702
  DEFINED_EXCEPTION("NO_DATA_NEEDED", OB_ERR_NO_DATA_NEEDED), // ORA-6548
14703

14704
  DEFINED_EXCEPTION("NOT_LOGGED_ON", OB_ERR_NOT_LOGGED_ON), // ORA-1012
14705
  DEFINED_EXCEPTION("PROGRAM_ERROR", OB_ERR_PROGRAM_ERROR), // ORA-6501
14706
  DEFINED_EXCEPTION("ROWTYPE_MISMATCH", OB_ERR_ROWTYPE_MISMATCH), // ORA-6504
14707
  DEFINED_EXCEPTION("SELF_IS_NULL", OB_ERR_SELF_IS_NULL), // ORA-30625
14708
  DEFINED_EXCEPTION("STORAGE_ERROR", OB_ERR_STORAGE_ERROR), // ORA-6500
14709

14710
  DEFINED_EXCEPTION("SUBSCRIPT_BEYOND_COUNT", OB_ERR_SUBSCRIPT_BEYOND_COUNT), // ORA-6533
14711
  DEFINED_EXCEPTION("SUBSCRIPT_OUTSIDE_LIMIT", OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT), // ORA-6532
14712
  DEFINED_EXCEPTION("SYS_INVALID_ROWID", OB_INVALID_ROWID), // ORA-1410
14713
  DEFINED_EXCEPTION("TIMEOUT_ON_RESOURCE", OB_ERR_TIMEOUT_ON_RESOURCE), // ORA-51
14714
  DEFINED_EXCEPTION("TOO_MANY_ROWS", OB_ERR_TOO_MANY_ROWS), // ORA-1422
14715

14716
  DEFINED_EXCEPTION("VALUE_ERROR", OB_ERR_NUMERIC_OR_VALUE_ERROR), // ORA-6502
14717
  DEFINED_EXCEPTION("ZERO_DIVIDE", OB_ERR_DIVISOR_IS_ZERO), // ORA-1476
14718
};
14719

14720
int ObPLResolver::resolve_pre_condition(const ObString &name, const ObPLConditionValue **value)
14721
{
14722
  int ret = OB_SUCCESS;
14723
  *value = NULL;
14724
  for (int64_t i = 0;
14725
       i < sizeof(PREDEFINED_EXCEPTIONS) / sizeof(PREDEFINED_EXCEPTIONS[0]);
14726
       ++i) {
14727
    if (0 == name.case_compare(PREDEFINED_EXCEPTIONS[i].name_)) {
14728
      *value = &(PREDEFINED_EXCEPTIONS[i].value_);
14729
      break;
14730
    }
14731
  }
14732
  return ret;
14733
}
14734

14735
int ObPLResolver::resolve_condition(const ObStmtNodeTree *parse_tree,
14736
                                    const ObPLBlockNS &ns,
14737
                                    const ObPLConditionValue **value,
14738
                                    ObPLCompileUnitAST &func)
14739
{
14740
  int ret = OB_SUCCESS;
14741
  CK (OB_NOT_NULL(parse_tree));
14742
  if (OB_FAIL(ret)) {
14743
  } else if (T_SP_ACCESS_NAME == parse_tree->type_) {
14744
    ObSchemaChecker schema_checker;
14745
    ObString db_name;
14746
    ObString package_name;
14747
    ObString condition_name;
14748
    ObString dblink_name;
14749
    OZ (schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
14750
    OZ (ObResolverUtils::resolve_sp_access_name(schema_checker,
14751
                                               resolve_ctx_.session_info_.get_effective_tenant_id(),
14752
                                               resolve_ctx_.session_info_.get_database_name(),
14753
                                               *parse_tree,
14754
                                               db_name,
14755
                                               package_name,
14756
                                               condition_name,
14757
                                               dblink_name));
14758
    if (OB_FAIL(ret)) {
14759
    } else if (package_name.empty()) {
14760
      if (!db_name.empty()
14761
          && db_name != resolve_ctx_.session_info_.get_database_name()) {
14762
        ret = OB_ERR_SP_COND_MISMATCH;
14763
        LOG_WARN("can not found continue",
14764
                 K(resolve_ctx_.session_info_.get_database_name()),
14765
                 K(db_name), K(package_name), K(condition_name));
14766
        LOG_USER_ERROR(OB_ERR_SP_COND_MISMATCH, condition_name.length(), condition_name.ptr());
14767
      } else {
14768
        OZ (resolve_condition(condition_name, ns, value));
14769
      }
14770
    } else if (db_name == resolve_ctx_.session_info_.get_database_name()
14771
               && package_name == ns.get_package_name()) {
14772
      // package_name is not null and equal to current ns, search local
14773
      OZ (resolve_condition(condition_name, ns, value));
14774
    } else {
14775
      // package name is not null and not equal to current ns, search global
14776
      uint64_t database_id = OB_INVALID_ID;
14777
      int64_t compatible_mode = lib::is_oracle_mode() ? COMPATIBLE_ORACLE_MODE
14778
                                                      : COMPATIBLE_MYSQL_MODE;
14779
      uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
14780
      const ObPackageInfo *package_info = NULL;
14781
      ObPLPackageManager &package_manager =
14782
        resolve_ctx_.session_info_.get_pl_engine()->get_package_manager();
14783
      db_name = db_name.empty() ? resolve_ctx_.session_info_.get_database_name() : db_name;
14784
      const ObPLCondition *condition = NULL;
14785
      OZ (resolve_ctx_.schema_guard_.get_database_id(tenant_id, db_name, database_id));
14786
      OZ (resolve_ctx_.schema_guard_.get_package_info(
14787
          tenant_id, database_id, package_name, PACKAGE_TYPE, compatible_mode, package_info));
14788
      if (OB_SUCC(ret)
14789
          && OB_ISNULL(package_info)
14790
          && 0 == db_name.case_compare(OB_SYS_DATABASE_NAME)) {
14791
        OZ (resolve_ctx_.schema_guard_.get_package_info(OB_SYS_TENANT_ID,
14792
                                                OB_SYS_DATABASE_ID,
14793
                                                package_name, PACKAGE_TYPE,
14794
                                                compatible_mode, package_info));
14795
      }
14796
      if (OB_SUCC(ret) && OB_ISNULL(package_info)) {
14797
        ret = OB_ERR_PACKAGE_DOSE_NOT_EXIST;
14798
        LOG_WARN("package not exist", K(ret), K(package_name), K(db_name));
14799
        LOG_USER_ERROR(OB_ERR_PACKAGE_DOSE_NOT_EXIST, "PACKAGE",
14800
                       db_name.length(), db_name.ptr(),
14801
                       package_name.length(), package_name.ptr());
14802
      }
14803
      OZ (package_manager.get_package_condition(resolve_ctx_,
14804
                                                package_info->get_package_id(),
14805
                                                condition_name,
14806
                                                condition));
14807
      if (OB_SUCC(ret) && OB_ISNULL(condition)) {
14808
        ret = OB_ERR_SP_COND_MISMATCH;
14809
        LOG_WARN("can not found continue",
14810
                 K(resolve_ctx_.session_info_.get_database_name()),
14811
                 K(db_name), K(package_name), K(condition_name));
14812
        LOG_USER_ERROR(OB_ERR_SP_COND_MISMATCH, condition_name.length(), condition_name.ptr());
14813
      }
14814
      if (OB_SUCC(ret) && OB_NOT_NULL(condition) && condition->get_duplicate()) {
14815
        ret = OB_ERR_SP_DUP_CONDITION;
14816
        LOG_WARN("duplicate condition declare", K(ret), K(condition_name));
14817
        LOG_USER_ERROR(OB_ERR_SP_DUP_CONDITION, condition_name.length(), condition_name.ptr());
14818
      }
14819
      if (OB_SUCC(ret)) {
14820
        ObSchemaObjVersion obj_version;
14821
        obj_version.object_id_ = package_info->get_package_id();
14822
        obj_version.object_type_ = DEPENDENCY_PACKAGE;
14823
        obj_version.version_ = package_info->get_schema_version();
14824
        OZ (func.add_dependency_object(obj_version));
14825
        OX (func.set_rps());
14826
      }
14827
      OX (*value = &(condition->get_value()));
14828
    }
14829
  } else if (T_IDENT == parse_tree->type_) {
14830
    OZ (resolve_condition(ObString(parse_tree->str_len_, parse_tree->str_value_), ns, value));
14831
  } else {
14832
    ret = OB_ERR_UNEXPECTED;
14833
    LOG_WARN("unexpected continue node type", K(ret), K(parse_tree->type_));
14834
  }
14835
  return ret;
14836
}
14837

14838
int ObPLResolver::resolve_condition(const ObString &name, const ObPLBlockNS &ns, const ObPLConditionValue **value)
14839
{
14840
  int ret = OB_SUCCESS;
14841
  if (OB_ISNULL(value)) {
14842
    ret = OB_ERR_UNEXPECTED;
14843
    LOG_WARN("Argument is NULL", K(value), K(ret));
14844
  } else {
14845
    *value = NULL;
14846
    const ObPLConditionTable *condition_table = NULL;
14847
    if (OB_ISNULL(condition_table = ns.get_condition_table())) {
14848
      ret = OB_ERR_UNEXPECTED;
14849
      LOG_WARN("Symbol table is NULL", K(condition_table), K(ret));
14850
    } else {
14851
      for (int64_t i = 0; OB_SUCC(ret) && i < ns.get_conditions().count(); ++i) {
14852
        const ObPLCondition *condition = condition_table->get_condition(ns.get_conditions().at(i));
14853
        if (OB_ISNULL(condition)) {
14854
          ret = OB_ERR_UNEXPECTED;
14855
          LOG_WARN("Get a invalid var", K(i), K(ns.get_conditions().at(i)), K(ret));
14856
        } else if (0 == name.case_compare(condition->get_name())) {
14857
          if (condition->get_duplicate()) {
14858
            ret = OB_ERR_SP_DUP_CONDITION;
14859
            LOG_WARN("duplicate condition declare", K(ret), K(name));
14860
            LOG_USER_ERROR(OB_ERR_SP_DUP_CONDITION, name.length(), name.ptr());
14861
          } else {
14862
            *value = &condition->get_value();
14863
          }
14864
        }
14865
      }
14866

14867
      if (OB_SUCC(ret) && NULL == *value) {
14868
        if (NULL == ns.get_pre_ns()) {
14869
          if (lib::is_oracle_mode()) {
14870
            if (OB_NOT_NULL(ns.get_external_ns())
14871
                && OB_NOT_NULL(ns.get_external_ns()->get_parent_ns())) {
14872
              OZ (SMART_CALL(resolve_condition(
14873
                name, *(ns.get_external_ns()->get_parent_ns()), value)));
14874
            } else {
14875
              OZ (resolve_pre_condition(name, value)); // check predefine exception
14876
            }
14877
          }
14878
          if (OB_SUCC(ret) && OB_ISNULL(*value)) {
14879
            ret = OB_ERR_SP_COND_MISMATCH;
14880
            LOG_USER_ERROR(OB_ERR_SP_COND_MISMATCH, name.length(), name.ptr());
14881
          }
14882
        } else {
14883
          OZ (SMART_CALL(resolve_condition(name, *ns.get_pre_ns(), value)));
14884
        }
14885
      }
14886
    }
14887
  }
14888
  return ret;
14889
}
14890

14891
int ObPLResolver::resolve_handler_condition(const ObStmtNodeTree *parse_tree,
14892
                                            ObPLConditionValue &condition,
14893
                                            ObPLCompileUnitAST &func)
14894
{
14895
  int ret = OB_SUCCESS;
14896
  if (OB_ISNULL(parse_tree)) {
14897
    ret = OB_ERR_UNEXPECTED;
14898
    LOG_WARN("Invalid Argument", K(parse_tree), K(ret));
14899
  } else if (T_SP_EXCEPTION_OTHERS == parse_tree->type_
14900
          || T_SQL_WARNING == parse_tree->type_
14901
          || T_SQL_NOT_FOUND == parse_tree->type_
14902
          || T_SQL_EXCEPTION == parse_tree->type_) {
14903
    condition.type_ = static_cast<ObPLConditionType>(parse_tree->type_ - T_SQL_EXCEPTION + SQL_EXCEPTION);
14904
  } else if (T_SP_CONDITION == parse_tree->type_) {
14905
    if (OB_FAIL(resolve_condition_value(parse_tree, condition,
14906
                                        is_sys_database_id(func.get_database_id())))) {
14907
      LOG_WARN("failed to resolve condition", K(parse_tree), K(ret));
14908
    }
14909
  } else if (T_IDENT == parse_tree->type_ // for mysql mode
14910
            || T_SP_ACCESS_NAME == parse_tree->type_) { // for oracle mode
14911
    const ObPLConditionValue *value = NULL;
14912
    CK (OB_NOT_NULL(current_block_));
14913
    OZ (resolve_condition(parse_tree, current_block_->get_namespace(), &value, func));
14914
    CK (OB_NOT_NULL(value));
14915
    OX (condition = *value);
14916
  } else {
14917
    ret = OB_ERR_UNEXPECTED;
14918
    LOG_WARN("Invalid condition type", K(parse_tree->type_), K(ret));
14919
  }
14920
  return ret;
14921
}
14922

14923
int ObPLResolver::resolve_condition_value(const ObStmtNodeTree *parse_tree,
14924
                                          ObPLConditionValue &value,
14925
                                          const bool is_sys_db)
14926
{
14927
  int ret = OB_SUCCESS;
14928
  if (OB_ISNULL(parse_tree)) {
14929
    ret = OB_ERR_UNEXPECTED;
14930
    LOG_WARN("Invalid Argument", K(parse_tree), K(ret));
14931
  } else if (lib::is_mysql_mode()) {
14932
    if (T_SP_CONDITION != parse_tree->type_ || OB_ISNULL(parse_tree->children_[0])) {
14933
      ret = OB_ERR_UNEXPECTED;
14934
      LOG_WARN("Invalid condition type", K(parse_tree->type_), K(ret));
14935
    } else if (T_SQL_STATE == parse_tree->children_[0]->type_) {
14936
      value.type_ = SQL_STATE;
14937
      if (OB_ISNULL(parse_tree->children_[0]->children_[0]) || T_VARCHAR != parse_tree->children_[0]->children_[0]->type_) {
14938
        ret = OB_ERR_UNEXPECTED;
14939
        LOG_WARN("Invalid condition type", K(parse_tree->children_[0]->children_[0]), K(ret));
14940
      } else {
14941
        value.sql_state_ = parse_tree->children_[0]->children_[0]->str_value_;
14942
        value.str_len_ = parse_tree->children_[0]->children_[0]->str_len_;
14943
      }
14944
    } else if (T_INT == parse_tree->children_[0]->type_) {
14945
      value.type_ = ERROR_CODE;
14946
      value.error_code_ = parse_tree->children_[0]->value_;
14947
      if (lib::is_oracle_mode()) {
14948
        if (value.error_code_ >= 0) {
14949
          ret = OB_ERR_ILLEGAL_ERROR_NUM;
14950
          LOG_WARN("PLS-00701: PRAGMA EXCEPTION_INIT 的非法 ORACLE 错误号", K(ret));
14951
        }
14952
      }
14953
      OX (value.sql_state_ = ob_sqlstate(static_cast<int>(value.error_code_)));
14954
      OX (value.str_len_ = STRLEN(value.sql_state_));
14955
    } else {
14956
      ret = OB_ERR_UNEXPECTED;
14957
      LOG_WARN("Invalid condition type", K(parse_tree->children_[0]->type_), K(ret));
14958
    }
14959
  } else {
14960
    if (T_INT == parse_tree->type_
14961
        || (T_VARCHAR == parse_tree->type_ && is_sys_db)) {
14962
      value.error_code_ = (T_INT == parse_tree->type_ 
14963
        ? parse_tree->value_ : static_cast<int64_t>(strtoll(parse_tree->str_value_, NULL, 10)));
14964
      if (value.error_code_ >= 0) {
14965
        ret = OB_ERR_ILLEGAL_ERROR_NUM;
14966
        LOG_WARN("illega error number for PRAGMA EXCEPTION_INIT", K(ret));
14967
      }
14968
      OX (value.type_ = ERROR_CODE);
14969
      OX (value.sql_state_ = ob_sqlstate(static_cast<int>(value.error_code_)));
14970
      OX (value.str_len_ = STRLEN(value.sql_state_));
14971
    } else {
14972
      ret = OB_ERR_EX_SECOND_ARG;
14973
      LOG_WARN("second argument to PRAGMA EXCEPTION_INIT must be a numeric literal", K(ret));
14974
    }
14975
  }
14976
  return ret;
14977
}
14978

14979
int ObPLResolver::check_duplicate_condition(const ObPLDeclareHandlerStmt &stmt,
14980
                                            const ObPLConditionValue &value,
14981
                                            bool &dup,
14982
                                            ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc* cur_desc)
14983
{
14984
  int ret = OB_SUCCESS;
14985
  dup = false;
14986
  for (int64_t i = 0; OB_SUCC(ret) && !dup && i < stmt.get_handlers().count(); ++i) {
14987
    ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = stmt.get_handler(i).get_desc();
14988
    if (OB_ISNULL(desc)) {
14989
      ret = OB_ERR_UNEXPECTED;
14990
      LOG_WARN("Handler is NULL", K(i), K(stmt.get_handler(i)), K(ret));
14991
    } else {
14992
      for (int64_t j = 0; !dup && j < desc->get_conditions().count(); ++j) {
14993
        if (value.type_ == desc->get_condition(j).type_ &&
14994
            value.error_code_ == desc->get_condition(j).error_code_ &&
14995
            value.str_len_ == desc->get_condition(j).str_len_ &&
14996
            0 == STRNCMP(value.sql_state_, desc->get_condition(j).sql_state_, value.str_len_)) {
14997
          dup = true;
14998
        }
14999
      }
15000
    }
15001
  }
15002
  for (int64_t i = handler_analyzer_.get_stack_depth() - 1; OB_SUCC(ret) && !dup && i >= 0; --i) {
15003
    ObPLDeclareHandlerStmt::DeclareHandler handler;
15004
    if (OB_FAIL(handler_analyzer_.get_handler(i, handler))) {
15005
      LOG_WARN("failed to get handler from handler analyzer", K(ret), K(i));
15006
    } else if (handler.get_level() == current_level_) {
15007
      ObPLDeclareHandlerStmt::DeclareHandler::HandlerDesc *desc = handler.get_desc();
15008
      if (OB_ISNULL(desc)) {
15009
        ret = OB_ERR_UNEXPECTED;
15010
        LOG_WARN("Handler desc is NULL", K(ret), K(i), K(handler));
15011
      } else if (desc->is_continue()) {
15012
        for (int64_t j = 0; !dup && j < desc->get_conditions().count(); ++j) {
15013
          if (value.type_ == desc->get_condition(j).type_ &&
15014
              value.error_code_ == desc->get_condition(j).error_code_ &&
15015
              value.str_len_ == desc->get_condition(j).str_len_ &&
15016
              0 == STRNCMP(value.sql_state_, desc->get_condition(j).sql_state_, value.str_len_)) {
15017
            dup = true;
15018
          }
15019
        }
15020
      }
15021
    } else {
15022
      break;
15023
    }
15024
  }
15025
  if (OB_NOT_NULL(cur_desc)) {
15026
    for (int64_t j = 0; !dup && j < cur_desc->get_conditions().count(); ++j) {
15027
      if (value.type_ == cur_desc->get_condition(j).type_ &&
15028
          value.error_code_ == cur_desc->get_condition(j).error_code_ &&
15029
          value.str_len_ == cur_desc->get_condition(j).str_len_ &&
15030
          0 == STRNCMP(value.sql_state_, cur_desc->get_condition(j).sql_state_, value.str_len_)) {
15031
        dup = true;
15032
      }
15033
    }
15034
  }
15035
  return ret;
15036
}
15037

15038
// build oracle sequence_object.currval, sequence_object.nextval expr
15039
int ObPLResolver::build_seq_value_expr(ObRawExpr *&expr,
15040
                                       const ObQualifiedName &q_name,
15041
                                       uint64_t seq_id)
15042
{
15043
  int ret = OB_SUCCESS;
15044
  ObSequenceRawExpr *func_expr = NULL;
15045
  ObConstRawExpr *col_id_expr = NULL;
15046
  ObSQLSessionInfo& session_info = resolve_ctx_.session_info_;
15047

15048
  if (0 == q_name.col_name_.case_compare("CURRVAL")) {
15049
    if (OB_FAIL(expr_factory_.create_raw_expr(T_FUN_SYS_SEQ_NEXTVAL, func_expr))) {
15050
      LOG_WARN("create currval failed", K(ret));
15051
    } else if (OB_FAIL(expr_factory_.create_raw_expr(T_UINT64, col_id_expr))) {
15052
      LOG_WARN("create const raw expr failed", K(ret));
15053
    } else {
15054
      if (OB_ISNULL(func_expr) || OB_ISNULL(col_id_expr)){
15055
        ret = OB_ERR_UNEXPECTED;
15056
        LOG_WARN("unexpected to get a null func expr", K(func_expr), K(col_id_expr), K(ret));
15057
      } else {
15058
        ObObj col_id;
15059
        col_id.set_uint64(seq_id);
15060
        col_id_expr->set_value(col_id);
15061
        if (OB_FAIL(func_expr->set_sequence_meta(q_name.database_name_, q_name.tbl_name_, q_name.col_name_, seq_id))) {
15062
          LOG_WARN("failed to set sequence meta", K(ret));
15063
        } else if (OB_FAIL(func_expr->add_flag(IS_SEQ_EXPR))) {
15064
          LOG_WARN("failed to add flag", K(ret));
15065
        } else if (OB_FAIL(func_expr->add_param_expr(col_id_expr))) {
15066
          LOG_WARN("set funcation param expr failed", K(ret));
15067
        } else if (OB_FAIL(func_expr->formalize(&session_info))) {
15068
          LOG_WARN("failed to extract info", K(ret));
15069
        } else {
15070
          expr = func_expr;
15071
        }
15072
      }
15073
    }
15074
  } else if (0 == q_name.col_name_.case_compare("NEXTVAL")) {
15075
    if (OB_FAIL(expr_factory_.create_raw_expr(T_FUN_SYS_PL_SEQ_NEXT_VALUE, func_expr))) {
15076
      LOG_WARN("create nextval failed", K(ret));
15077
    } else if (OB_FAIL(expr_factory_.create_raw_expr(T_UINT64, col_id_expr))) {
15078
      LOG_WARN("create const raw expr failed", K(ret));
15079
    } else {
15080
      if (OB_ISNULL(func_expr) || OB_ISNULL(col_id_expr)){
15081
        ret = OB_ERR_UNEXPECTED;
15082
        LOG_WARN("unexpected to get a null func expr", K(func_expr), K(col_id_expr), K(ret));
15083
      } else {
15084
        ObObj col_id;
15085
        func_expr->set_sequence_meta(q_name.database_name_, q_name.tbl_name_, q_name.col_name_, seq_id);
15086
        col_id.set_uint64(seq_id);
15087
        col_id_expr->set_value(col_id);
15088
        if (OB_FAIL(func_expr->add_param_expr(col_id_expr))) {
15089
          LOG_WARN("set funcation param expr failed", K(ret));
15090
        } else if (OB_FAIL(func_expr->formalize(&session_info))) {
15091
          LOG_WARN("failed to extract info", K(ret));
15092
        } else {
15093
          expr = func_expr;
15094
        }
15095
      }
15096
    }
15097
  } else {
15098
    ret = OB_INVALID_ARGUMENT;
15099
    LOG_WARN("resolve failed, invalid sequence field name.", K(ret));
15100
  }
15101
  return ret;
15102
}
15103

15104

15105
int ObPLResolver::resolve_sequence_object(const ObQualifiedName &q_name,
15106
                                          ObPLCompileUnitAST &unit_ast,
15107
                                          ObRawExpr *&real_ref_expr)
15108
{
15109
  int ret = OB_SUCCESS;
15110
  uint64_t seq_id = OB_INVALID_ID;
15111
  ObSynonymChecker syn_checker;
15112
  ObSchemaChecker sc;
15113
  if (0 == q_name.col_name_.case_compare("NEXTVAL") ||
15114
      0 == q_name.col_name_.case_compare("CURRVAL")) {
15115
    if (OB_FAIL(sc.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()))) {
15116
      LOG_WARN("init schemachecker failed.");
15117
    } else {
15118
      // check if sequence is created. will also check synonym
15119
      if (OB_FAIL(ob_sequence_ns_checker_.check_sequence_namespace(q_name,
15120
                                                                  syn_checker,
15121
                                                                  &resolve_ctx_.session_info_,
15122
                                                                  &sc,
15123
                                                                  seq_id))) {
15124
        LOG_WARN_IGNORE_COL_NOTFOUND(ret, "check basic column namespace failed", K(ret), K(q_name));
15125
      } else if(OB_FAIL(build_seq_value_expr(real_ref_expr, q_name, seq_id))) {
15126
        LOG_WARN("failed to resolve seq.", K(ret));
15127
      } else {
15128
        int64_t schema_version = OB_INVALID_VERSION;
15129
        ObSchemaObjVersion obj_version;
15130
        const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
15131
        OZ (resolve_ctx_.schema_guard_.get_schema_version(SEQUENCE_SCHEMA,
15132
                                                          tenant_id,
15133
                                                          seq_id,
15134
                                                          schema_version));
15135
        CK (schema_version != OB_INVALID_VERSION);
15136
        OX (obj_version.object_id_ = seq_id);
15137
        OX (obj_version.object_type_ = DEPENDENCY_SEQUENCE);
15138
        OX (obj_version.version_ = schema_version);
15139
        OZ (unit_ast.add_dependency_object(obj_version));
15140
      }
15141
      if (OB_SUCC(ret)) {
15142
        unit_ast.set_has_sequence();
15143
      }
15144
    }
15145
  } else {
15146
    ret = OB_ERR_SP_UNDECLARED_VAR;
15147
    LOG_WARN("sequence access bad field.", K(ret));
15148
  }
15149
  return ret;
15150
}
15151

15152
/**
15153
  Sanity check for SQLSTATEs. The function does not check if it's really an
15154
  existing SQL-state (there are just too many), it just checks string length and
15155
  looks for bad characters.
15156

15157
  @param sqlstate the condition SQLSTATE.
15158

15159
  @retval true if it's ok.
15160
  @retval false if it's bad.
15161
*/
15162
bool ObPLResolver::is_sqlstate_valid(const char* sql_state, const int64_t &str_len)
15163
{
15164
  bool ret = true;
15165
  if (str_len != 5 || NULL == sql_state) {
15166
    ret = false;
15167
  } else {
15168
    for (int i = 0 ; i < 5; ++i) {
15169
      char c = sql_state[i];
15170
      if ((c < '0' || '9' < c)
15171
          && (c < 'A' || 'Z' < c)) {
15172
        ret = false;
15173
        break;
15174
      }
15175
    }
15176
  }
15177
  return ret;
15178
}
15179

15180
/**
15181
  Checks if the specified SQL-state-string defines COMPLETION condition.
15182
  This function assumes that the given string contains a valid SQL-state.
15183

15184
  @param s the condition SQLSTATE.
15185

15186
  @retval true if the given string defines COMPLETION condition.
15187
  @retval false otherwise.
15188
*/
15189
bool ObPLResolver::is_sqlstate_completion(const char *sql_state)
15190
{
15191
  return sql_state[0] == '0' && sql_state[1] == '0';
15192
}
15193

15194
int ObPLResolver::analyze_actual_condition_type(const ObPLConditionValue &value, ObPLConditionType &type)
15195
{
15196
  int ret = OB_SUCCESS;
15197
  type = INVALID_TYPE;
15198
  switch (value.type_) {
15199
  case ERROR_CODE: {
15200
    const char* state = ob_sqlstate(static_cast<int>(value.error_code_));
15201
    if (OB_UNLIKELY(NULL == state || STRLEN(state) < 5)) {
15202
        ret = OB_ERR_UNEXPECTED;
15203
        LOG_WARN("Invalid condition type", K(value), K(ret));
15204
      } else {
15205
        type = ObPLEH::eh_classify_exception(state);
15206
      }
15207
  }
15208
    break;
15209
  case SQL_STATE: {
15210
    /*
15211
      An error is triggered:
15212
        - if the specified string is not a valid SQLSTATE,
15213
        - or if it represents the completion condition -- it is not
15214
          allowed to SIGNAL, or declare a handler for the completion
15215
          condition.
15216
    */
15217
    if (!is_sqlstate_valid(value.sql_state_, value.str_len_)
15218
        || is_sqlstate_completion(value.sql_state_)) {
15219
      ret = OB_ER_SP_BAD_SQLSTATE;
15220
      LOG_USER_ERROR(OB_ER_SP_BAD_SQLSTATE, static_cast<int>(value.str_len_), value.sql_state_);
15221
      LOG_WARN("Bad SQLSTATE", K(value), K(ret));
15222
    } else {
15223
      type = ObPLEH::eh_classify_exception(value.sql_state_);
15224
    }
15225
  }
15226
    break;
15227
  case SQL_EXCEPTION:
15228
  case SQL_WARNING:
15229
  case NOT_FOUND:
15230
  case OTHERS: {
15231
    type = value.type_;
15232
  }
15233
    break;
15234
  default:{
15235
    ret = OB_ERR_UNEXPECTED;
15236
    LOG_WARN("Invalid condition type", K(value), K(ret));
15237
  }
15238
    break;
15239
  }
15240
  return ret;
15241
}
15242

15243
int ObPLResolver::HandlerAnalyzer::set_handlers(const common::ObIArray<ObPLDeclareHandlerStmt::DeclareHandler> &handlers, int64_t level)
15244
{
15245
  int ret = OB_SUCCESS;
15246
  for (int64_t i = 0; OB_SUCC(ret) && i < handlers.count(); ++i) {
15247
    if (OB_FAIL(set_handler(handlers.at(i).get_desc(), level))) {
15248
      LOG_WARN("failed to set handler", K(i), K(ret));
15249
    }
15250
  }
15251
  return ret;
15252
}
15253

15254
int ObPLResolver::HandlerAnalyzer::reset_handlers(int64_t level)
15255
{
15256
  int ret = OB_SUCCESS;
15257
  for (int64_t i = handler_stack_.count() - 1; OB_SUCC(ret) && i >= 0; --i) {
15258
    if (handler_stack_.at(i).get_level() == level) {
15259
      if (i != handler_stack_.count() -1) {
15260
        ret = OB_ERR_UNEXPECTED;
15261
        LOG_WARN("failed to reset handlers with level", K(ret), K(level), K(i), K(handler_stack_.at(i)));
15262
      } else {
15263
        handler_stack_.pop_back();
15264
      }
15265
    }
15266
  }
15267
  if (OB_SUCC(ret) && handler_stack_.count() - 1 < top_continue_) {
15268
    top_continue_ = OB_INVALID_INDEX;
15269
  }
15270
  return ret;
15271
}
15272

15273
int ObPLResolver::resolve_external_types_from_expr(ObRawExpr &expr)
15274
{
15275
  int ret = OB_SUCCESS;
15276
  if (expr.is_obj_access_expr()) {
15277
    ObObjAccessRawExpr &obj_access_expr = static_cast<ObObjAccessRawExpr&>(expr);
15278
    for (int64_t i = 0; OB_SUCC(ret) && i < obj_access_expr.get_access_idxs().count(); ++i) {
15279
      OZ (obj_access_expr.get_access_idxs().at(i).elem_type_.get_all_depended_user_type(
15280
          get_resolve_ctx(),
15281
          get_current_namespace()));
15282
      if (NULL != obj_access_expr.get_access_idxs().at(i).get_sysfunc_) {
15283
        OZ (resolve_external_types_from_expr(*obj_access_expr.get_access_idxs().at(i).get_sysfunc_));
15284
      }
15285
    }
15286
    for (int64_t i = 0; OB_SUCC(ret) && i < expr.get_param_count(); ++i) {
15287
      CK (OB_NOT_NULL(expr.get_param_expr(i)));
15288
      OZ (resolve_external_types_from_expr(*expr.get_param_expr(i)));
15289
    }
15290
  }
15291
  return ret;
15292
}
15293

15294
int ObPLResolver::add_external_cursor(ObPLBlockNS &ns,
15295
                                      const ObPLBlockNS *external_ns,
15296
                                      const ObPLCursor &cursor,
15297
                                      int64_t &index,
15298
                                      ObPLCompileUnitAST &func)
15299
{
15300
  int ret = OB_SUCCESS;
15301
  OX (index = OB_INVALID_INDEX);
15302
  CK (OB_NOT_NULL(ns.get_cursor_table()));
15303
  for (int64_t i = 0; OB_SUCC(ret) && i < ns.get_cursor_table()->get_count(); ++i) {
15304
    const ObPLCursor *tmp = ns.get_cursor_table()->get_cursor(i);
15305
    CK (OB_NOT_NULL(tmp));
15306
    if (OB_SUCC(ret)
15307
        && tmp->get_package_id() == cursor.get_package_id()
15308
        && tmp->get_routine_id() == cursor.get_routine_id()
15309
        && tmp->get_index() == cursor.get_index()) {
15310
      index = i;
15311
      break;
15312
    }
15313
  }
15314
  if (OB_SUCC(ret) && OB_INVALID_INDEX == index) {
15315
    ObIAllocator &allocator = resolve_ctx_.allocator_;
15316
    ObString sql;
15317
    ObString ps_sql;
15318
    ObRecordType *row_desc = NULL;
15319
    ObPLDataType cursor_type;
15320
    if (OB_NOT_NULL(cursor.get_row_desc())) {
15321
      row_desc = static_cast<ObRecordType *>(allocator.alloc(sizeof(ObRecordType)));
15322
      if (OB_ISNULL(row_desc)) {
15323
        ret = OB_ALLOCATE_MEMORY_FAILED;
15324
        LOG_WARN("failed to alloc record type for package cursor", K(ret));
15325
      }
15326
      row_desc = new(row_desc)ObRecordType();
15327
      OZ (row_desc->deep_copy(allocator, *(cursor.get_row_desc())));
15328
    }
15329
    OX (index = OB_INVALID_INDEX);
15330
    OZ (ob_write_string(allocator, cursor.get_sql(), sql));
15331
    OZ (ob_write_string(allocator, cursor.get_ps_sql(), ps_sql));
15332
    OZ (cursor_type.deep_copy(allocator, cursor.get_cursor_type()));
15333
    ObSEArray<int64_t, 4> sql_params;
15334

15335
    for (int64_t i = 0; OB_SUCC(ret) && i < cursor.get_sql_params().count(); ++i) {
15336
      ObRawExpr *expr = NULL;
15337
      ObRawExpr *org_expr = NULL;
15338
      if (NULL == external_ns) {
15339
        org_expr = reinterpret_cast<ObRawExpr*>(cursor.get_sql_params().at(i));
15340
      } else {
15341
        CK (OB_NOT_NULL(external_ns->get_exprs()));
15342
        CK (cursor.get_sql_params().at(i) >= 0
15343
            && cursor.get_sql_params().at(i) < external_ns->get_exprs()->count());
15344
        OX (org_expr = external_ns->get_exprs()->at(cursor.get_sql_params().at(i)));
15345
      }
15346
      OZ (ObPLExprCopier::copy_expr(expr_factory_, org_expr, expr));
15347
      CK (OB_NOT_NULL(expr));
15348
      OZ (resolve_external_types_from_expr(*expr));
15349
      OZ (func.add_expr(expr));
15350
      if (OB_SUCC(ret) && expr->is_obj_access_expr()) {
15351
        OZ (func.add_obj_access_expr(expr));
15352
      }
15353
      OZ (sql_params.push_back(func.get_expr_count() - 1));
15354
    }
15355
    CK (OB_NOT_NULL(ns.get_cursor_table()));
15356
    OZ (ns.get_cursor_table()->add_cursor(cursor.get_package_id(),
15357
                                          cursor.get_routine_id(),
15358
                                          cursor.get_index(),
15359
                                          sql,
15360
                                          sql_params,
15361
                                          ps_sql,
15362
                                          cursor.get_stmt_type(),
15363
                                          cursor.is_for_update(),
15364
                                          cursor.has_hidden_rowid(),
15365
                                          cursor.get_rowid_table_id(),
15366
                                          cursor.get_ref_objects(),
15367
                                          row_desc,
15368
                                          cursor_type,
15369
                                          cursor.get_formal_params(),
15370
                                          cursor.get_state(),
15371
                                          cursor.is_dup_column()));
15372
    OZ (ns.get_cursors().push_back(ns.get_cursor_table()->get_count() - 1));
15373
    OX (index = ns.get_cursor_table()->get_count() - 1);
15374
  }
15375
  return ret;
15376
}
15377

15378
int ObPLResolver::resolve_cursor(ObPLCompileUnitAST &func,
15379
                                 const ObPLBlockNS &ns,
15380
                                 const ObString &database_name,
15381
                                 const ObString &package_name,
15382
                                 const ObString &cursor_name,
15383
                                 int64_t &index)
15384
{
15385
  int ret = OB_SUCCESS;
15386
  const ObPLCursor *cursor = NULL;
15387
  // package name is not null and not equal to current ns, search global
15388
  uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
15389
  int64_t compatible_mode = lib::is_oracle_mode() ? COMPATIBLE_ORACLE_MODE
15390
                                                  : COMPATIBLE_MYSQL_MODE;
15391
  const ObPackageInfo *package_info = NULL;
15392
  ObPLPackageManager &package_manager =
15393
    resolve_ctx_.session_info_.get_pl_engine()->get_package_manager();
15394
  ObString db_name =
15395
    database_name.empty() ? resolve_ctx_.session_info_.get_database_name() : database_name;
15396
  uint64_t database_id = OB_INVALID_ID;
15397
  int64_t idx = OB_INVALID_INDEX;
15398
  CK (!package_name.empty());
15399
  CK (!cursor_name.empty());
15400
  OX (cursor = NULL);
15401
  OZ (resolve_ctx_.schema_guard_.get_database_id(tenant_id, db_name, database_id));
15402
  OZ (resolve_ctx_.schema_guard_.get_package_info(
15403
      tenant_id, database_id, package_name, PACKAGE_TYPE, compatible_mode, package_info));
15404
  if (OB_SUCC(ret)
15405
      && OB_ISNULL(package_info) && 0 == db_name.case_compare(OB_SYS_DATABASE_NAME)) {
15406
    OZ (resolve_ctx_.schema_guard_.get_package_info(
15407
      OB_SYS_TENANT_ID, OB_SYS_DATABASE_ID,
15408
      package_name, PACKAGE_TYPE, compatible_mode, package_info));
15409
  }
15410
  if (OB_SUCC(ret) && OB_ISNULL(package_info)) {
15411
    ObSchemaChecker checker;
15412
    ObSynonymChecker synonym_checker;
15413
    ObString new_package_name;
15414
    bool is_exist = false;
15415
    OZ (checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
15416
    OZ (ObResolverUtils::resolve_synonym_object_recursively(
15417
      checker, synonym_checker, tenant_id, database_id, package_name, database_id, new_package_name, is_exist));
15418
    if (OB_SUCC(ret) && is_exist) {
15419
      OZ (resolve_ctx_.schema_guard_.get_package_info(
15420
        tenant_id, database_id, new_package_name, PACKAGE_TYPE, compatible_mode, package_info));
15421
    }
15422
    if (OB_SUCC(ret)
15423
        && OB_ISNULL(package_info) && OB_SYS_DATABASE_ID == database_id) {
15424
      OZ (resolve_ctx_.schema_guard_.get_package_info(
15425
        OB_SYS_TENANT_ID, OB_SYS_DATABASE_ID, new_package_name, PACKAGE_TYPE, compatible_mode, package_info));
15426
    }
15427
  }
15428
  if ((OB_SUCC(ret) && OB_ISNULL(package_info)) || OB_SYNONYM_NOT_EXIST == ret) {
15429
    ret = OB_ERR_PACKAGE_DOSE_NOT_EXIST;
15430
    LOG_WARN("package not exist", K(ret), K(package_name), K(db_name));
15431
    LOG_USER_ERROR(OB_ERR_PACKAGE_DOSE_NOT_EXIST, "PACKAGE",
15432
                           db_name.length(), db_name.ptr(),
15433
                           package_name.length(), package_name.ptr());
15434
  }
15435
  if (OB_FAIL(ret)) {
15436
  } else if (OB_NOT_NULL(package_info)
15437
            && database_id == resolve_ctx_.session_info_.get_database_id()
15438
            && package_info->get_package_name() == ns.get_package_name()) {
15439
    // search local again, package name may synonym.
15440
    OZ (resolve_cursor(cursor_name, ns, index, func, false, true), K(cursor_name));
15441
  } else {
15442
    OZ (package_manager.get_package_cursor(
15443
          resolve_ctx_, package_info->get_package_id(), cursor_name, cursor, idx));
15444
    if (OB_SUCC(ret) && OB_ISNULL(cursor)) {
15445
      ret = OB_ERR_SP_CURSOR_MISMATCH;
15446
      LOG_WARN("can not found cursor",
15447
               K(resolve_ctx_.session_info_.get_database_name()),
15448
               K(db_name), K(package_name), K(cursor_name));
15449
      LOG_USER_ERROR(OB_ERR_SP_CURSOR_MISMATCH, cursor_name.length(), cursor_name.ptr());
15450
    }
15451
    OZ (func.add_dependency_objects(cursor->get_value().get_ref_objects()));
15452
    if (OB_SUCC(ret)) {
15453
      ObSchemaObjVersion obj_version;
15454
      obj_version.object_id_ = package_info->get_package_id();
15455
      obj_version.object_type_ = DEPENDENCY_PACKAGE;
15456
      obj_version.version_ = package_info->get_schema_version();
15457
      OZ (func.add_dependency_object(obj_version));
15458
      OX (func.set_rps());
15459
    }
15460
    CK (OB_NOT_NULL(cursor));
15461
    CK (OB_NOT_NULL(current_block_));
15462
    OZ (add_external_cursor(current_block_->get_namespace(), NULL, *cursor, index, func));
15463
  }
15464
  return ret;
15465
}
15466

15467
int ObPLResolver::resolve_cursor(
15468
  const ObStmtNodeTree *parse_tree, const ObPLBlockNS &ns,
15469
  int64_t &index, ObPLCompileUnitAST &func)
15470
{
15471
  int ret = OB_SUCCESS;
15472
  OX (index = OB_INVALID_INDEX);
15473
  CK (OB_NOT_NULL(parse_tree));
15474
  if (OB_FAIL(ret)) {
15475
  } else if (T_SP_ACCESS_NAME == parse_tree->type_) {
15476
    ObSchemaChecker schema_checker;
15477
    ObString db_name;
15478
    ObString package_name;
15479
    ObString cursor_name;
15480
    ObString dblink_name;
15481
    OZ (schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
15482
    OZ (ObResolverUtils::resolve_sp_access_name(
15483
      schema_checker, resolve_ctx_.session_info_.get_effective_tenant_id(),
15484
      resolve_ctx_.session_info_.get_database_name(),
15485
      *parse_tree, db_name, package_name, cursor_name, dblink_name));
15486
    if (OB_FAIL(ret)) {
15487
    } else if (package_name.empty()) {
15488
      if (!db_name.empty()
15489
          && db_name != resolve_ctx_.session_info_.get_database_name()) {
15490
        ret = OB_ERR_SP_CURSOR_MISMATCH;
15491
        LOG_WARN("can not found cursor",
15492
                 K(resolve_ctx_.session_info_.get_database_name()),
15493
                 K(db_name), K(package_name), K(cursor_name));
15494
        LOG_USER_ERROR(OB_ERR_SP_CURSOR_MISMATCH, cursor_name.length(), cursor_name.ptr());
15495
      } else {
15496
        OZ (resolve_cursor(cursor_name, ns, index, func), K(cursor_name));
15497
      }
15498
    } else if (db_name == resolve_ctx_.session_info_.get_database_name()
15499
               && package_name == ns.get_package_name()) {
15500
      // package_name is not null and equal to current ns, search local
15501
      OZ (resolve_cursor(cursor_name, ns, index, func, false, true), K(cursor_name));
15502
    } else {
15503
      // search global cursor
15504
      OZ (resolve_cursor(func, ns, db_name, package_name, cursor_name, index));
15505
    }
15506
  } else if (T_OBJ_ACCESS_REF == parse_tree->type_) {
15507
    CK (2 == parse_tree->num_child_);
15508
    if (parse_tree->children_[1] != nullptr) {
15509
      ObString db_name;
15510
      ObString package_name;
15511
      ObString cursor_name;
15512
      const ObStmtNodeTree *package_node = parse_tree->children_[0];
15513
      const ObStmtNodeTree *cursor_node = parse_tree->children_[1]->children_[0];
15514
      package_name.assign_ptr(package_node->str_value_, static_cast<int32_t>(package_node->str_len_));
15515
      if (T_FUN_SYS == cursor_node->type_
15516
          && OB_NOT_NULL(cursor_node->children_[0])
15517
          && T_IDENT == cursor_node->children_[0]->type_) {
15518
        cursor_name.assign_ptr(cursor_node->children_[0]->str_value_, static_cast<int32_t>(cursor_node->children_[0]->str_len_));
15519
      } else {
15520
        cursor_name.assign_ptr(cursor_node->str_value_, static_cast<int32_t>(cursor_node->str_len_));
15521
      }
15522
      db_name = resolve_ctx_.session_info_.get_database_name();
15523
      if (OB_FAIL(ret)) {
15524
      } else if (package_name.empty()) {
15525
        ret = OB_ERR_SP_CURSOR_MISMATCH;
15526
        LOG_WARN("can not found cursor",
15527
                 K(resolve_ctx_.session_info_.get_database_name()),
15528
                 K(db_name), K(package_name), K(cursor_name));
15529
        LOG_USER_ERROR(OB_ERR_SP_CURSOR_MISMATCH, cursor_name.length(), cursor_name.ptr());
15530
      } else if (package_name == ns.get_package_name()) {
15531
        OZ (resolve_cursor(cursor_name, ns, index, func, false, true), cursor_name);
15532
      } else {
15533
        // search global cursor
15534
        OZ (resolve_cursor(func, ns, db_name, package_name, cursor_name, index));
15535
      }
15536
    } else {
15537
      const ObStmtNodeTree *cursor_name = parse_tree->children_[0];
15538
      if (T_IDENT == cursor_name->type_) {
15539
        OZ (resolve_cursor(ObString(cursor_name->str_len_, cursor_name->str_value_), ns, index, func));
15540
      } else if (T_QUESTIONMARK == cursor_name->type_) {
15541
        OZ (resolve_questionmark_cursor(cursor_name->value_, current_block_->get_namespace(), index));
15542
      } else {
15543
        ret = OB_ERR_UNEXPECTED;
15544
        LOG_WARN("unexpected cursor node type", K(ret), K(cursor_name->type_));
15545
      }
15546
    }
15547
  } else if (T_IDENT == parse_tree->type_) {
15548
    OZ (resolve_cursor(ObString(parse_tree->str_len_, parse_tree->str_value_), ns, index, func));
15549
  } else if (T_QUESTIONMARK == parse_tree->type_) {
15550
    OZ (resolve_questionmark_cursor(parse_tree->value_, current_block_->get_namespace(), index));
15551
  } else {
15552
    ret = OB_ERR_UNEXPECTED;
15553
    LOG_WARN("unexpected cursor node type", K(ret), K(parse_tree->type_));
15554
  }
15555
  return ret;
15556
}
15557

15558
int ObPLResolver::resolve_questionmark_cursor(
15559
  const int64_t symbol_idx, ObPLBlockNS &ns, int64_t &cursor)
15560
{
15561
  // question mark 一定是当前 ns, 里的，所以不需要去别的 ns 找
15562
  int ret = OB_SUCCESS;
15563
  cursor = OB_INVALID_INDEX;
15564
  const ObPLSymbolTable *symbol_table = ns.get_symbol_table();
15565
  const ObPLCursorTable *cursor_table = ns.get_cursor_table();
15566
  CK (OB_NOT_NULL(symbol_table));
15567
  CK (OB_NOT_NULL(cursor_table));
15568
  for (int64_t i = 0;
15569
       OB_SUCC(ret) && OB_INVALID_INDEX == cursor && i < ns.get_cursors().count(); ++i) {
15570
    const ObPLVar *var = NULL;
15571
    const ObPLCursor *cur = cursor_table->get_cursor(ns.get_cursors().at(i));
15572
    CK (OB_NOT_NULL(cur));
15573
    if (ns.get_package_id() != cur->get_package_id()
15574
        || ns.get_routine_id() != cur->get_routine_id()) {
15575
      //外部cursor，跳过即可
15576
    } else {
15577
      CK (OB_NOT_NULL(var = symbol_table->get_symbol(cur->get_index())));
15578
      if (OB_SUCC(ret) && symbol_idx == cur->get_index()) {
15579
        if (ns.get_block_type() != ObPLBlockNS::BLOCK_ROUTINE
15580
            || ns.get_symbol_table() != current_block_->get_namespace().get_symbol_table()) {
15581
          ret = OB_NOT_SUPPORTED;
15582
          LOG_WARN("questionmark cursor only resolve at itself namespace.", K(symbol_idx));
15583
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "resolve questionmark cursor at not its own namespace");
15584
        } else {
15585
          cursor = ns.get_cursors().at(i);
15586
        }
15587
        if (OB_SUCC(ret) && ObPLCursor::DUP_DECL == cur->get_state()) {
15588
          ret = OB_ERR_SP_DUP_CURSOR;
15589
          LOG_WARN("too many declarations of cursor match this call", K(ret), K(symbol_idx));
15590
        }
15591
        break;
15592
      }
15593
    }
15594
  }
15595
  if (OB_SUCC(ret) && OB_INVALID_INDEX == cursor) {
15596
    if (OB_FAIL(ns.add_questionmark_cursor(symbol_idx))) {
15597
      LOG_WARN("failed to add condition", K(ret));
15598
    } else {
15599
      ObPLVar *var = const_cast<ObPLVar *>(ns.get_symbol_table()->get_symbol(symbol_idx));
15600
      if (OB_ISNULL(var)) {
15601
        ret = OB_ERR_UNEXPECTED;
15602
        LOG_WARN("get invalid symbol.", K(symbol_idx));
15603
      } else {
15604
        var->set_readonly(false);
15605
        var->set_type(PL_CURSOR_TYPE);
15606
        var->get_type().set_sys_refcursor_type();
15607
        cursor = ns.get_cursors().at(ns.get_cursors().count() - 1);
15608
      }
15609
    }
15610
  }
15611
  return ret;
15612
}
15613

15614
int ObPLResolver::resolve_cursor(
15615
  const ObString &name, const ObPLBlockNS &ns,
15616
  int64_t &cursor, ObPLCompileUnitAST &func, bool check_mode, bool for_external_cursor)
15617
{
15618
  int ret = OB_SUCCESS;
15619
  cursor = OB_INVALID_INDEX;
15620
  const ObPLSymbolTable *symbol_table = ns.get_symbol_table();
15621
  const ObPLCursorTable *cursor_table = ns.get_cursor_table();
15622
  CK (OB_NOT_NULL(symbol_table));
15623
  CK (OB_NOT_NULL(cursor_table));
15624
  for (int64_t i = 0;
15625
       OB_SUCC(ret)
15626
       && (for_external_cursor ? ns.get_block_type() != ObPLBlockNS::BLOCK_ROUTINE : true)
15627
       && OB_INVALID_INDEX == cursor
15628
       && i < ns.get_cursors().count();
15629
       ++i) {
15630
    const ObPLVar *var = NULL;
15631
    const ObPLCursor *cur = cursor_table->get_cursor(ns.get_cursors().at(i));
15632
    CK (OB_NOT_NULL(cur));
15633
    if (ns.get_package_id() != cur->get_package_id()
15634
        || ns.get_routine_id() != cur->get_routine_id()) {
15635
      // external cursor will search by iterator namespace, here do not check, do nothing ...
15636
    } else {
15637
      OV (OB_NOT_NULL(var = symbol_table->get_symbol(cur->get_index())),
15638
        OB_ERR_UNEXPECTED, KPC(cur), K(ns.get_package_id()), K(ns.get_routine_id()));
15639
    }
15640
    if (OB_SUCC(ret) && OB_NOT_NULL(var) && 0 == name.case_compare(var->get_name())) {
15641
      if (ns.get_block_type() != ObPLBlockNS::BLOCK_ROUTINE
15642
          || ns.get_symbol_table() != current_block_->get_namespace().get_symbol_table()) {
15643
        CK (OB_NOT_NULL(current_block_));
15644
        OZ (add_external_cursor(current_block_->get_namespace(),
15645
                                &ns,
15646
                                *cur,
15647
                                cursor,
15648
                                func));
15649
      } else {
15650
        cursor = ns.get_cursors().at(i);
15651
      }
15652
      if (OB_SUCC(ret) && !check_mode && ObPLCursor::DUP_DECL == cur->get_state()) {
15653
        ret = OB_ERR_SP_DUP_CURSOR;
15654
        LOG_WARN("too many declarations of cursor match this call", K(ret), K(name));
15655
      }
15656
      break;
15657
    }
15658
  }
15659

15660
  if (OB_SUCC(ret)
15661
      && OB_INVALID_INDEX == cursor
15662
      && (!check_mode || ns.get_block_type() != ObPLBlockNS::BLOCK_ROUTINE)) {
15663
    if (OB_NOT_NULL(ns.get_pre_ns())) {
15664
      OZ (SMART_CALL(resolve_cursor(name,
15665
                                    *ns.get_pre_ns(),
15666
                                    cursor,
15667
                                    func,
15668
                                    check_mode,
15669
                                    for_external_cursor)), K(name));
15670
    } else if (OB_NOT_NULL(ns.get_external_ns())
15671
               && OB_NOT_NULL(ns.get_external_ns()->get_parent_ns())) {
15672
      OZ (SMART_CALL(resolve_cursor(name,
15673
                                    *(ns.get_external_ns()->get_parent_ns()),
15674
                                    cursor,
15675
                                    func,
15676
                                    check_mode,
15677
                                    for_external_cursor)), K(name));
15678
    } else if (check_mode) {
15679
      LOG_DEBUG("can not found cursor", K(name));
15680
    } else {
15681
      ret = OB_ERR_SP_CURSOR_MISMATCH;
15682
      LOG_WARN("can not found cursor", K(ret), K(name));
15683
      LOG_USER_ERROR(OB_ERR_SP_CURSOR_MISMATCH, name.length(), name.ptr());
15684
    }
15685
  }
15686
  return ret;
15687
}
15688

15689
int ObPLResolver::resolve_label(const ObString &name,
15690
                                const ObPLBlockNS &ns,
15691
                                int64_t &label,
15692
                                bool is_iterate_label)
15693
{
15694
  int ret = OB_SUCCESS;
15695
  label = OB_INVALID_INDEX;
15696
  const ObPLLabelTable *label_table = ns.get_label_table();
15697
  if (OB_ISNULL(label_table)) {
15698
    ret = OB_ERR_UNEXPECTED;
15699
    LOG_WARN("Symbol table is NULL", K(label_table), K(label), K(ret));
15700
  } else {
15701
    for (int64_t i = 0; OB_SUCC(ret) && OB_INVALID_INDEX == label && i < ns.get_labels().count(); ++i) {
15702
      const ObString *label_name = label_table->get_label(ns.get_labels().at(i));
15703
      if (OB_ISNULL(label_name)) {
15704
        ret = OB_ERR_UNEXPECTED;
15705
        LOG_WARN("label is NULL", K(label_name), K(label), K(ret));
15706
      } else if (0 == name.case_compare(*label_name)) {
15707
        if (is_iterate_label) {
15708
          ObPLLabelTable::ObPLLabelType type = label_table->get_label_type(ns.get_labels().at(i));
15709
          if (ObPLLabelTable::ObPLLabelType::LABEL_CONTROL == type) {
15710
            label = ns.get_labels().at(i);
15711
          }
15712
        } else {
15713
          label = ns.get_labels().at(i);
15714
        }
15715
        break;
15716
      } else { /*do nothing*/ }
15717
    }
15718

15719
    if (OB_SUCC(ret) && OB_INVALID_INDEX == label) {
15720
      if (ns.stop_search_label() || NULL == ns.get_pre_ns()) {
15721
        ret = OB_ERR_SP_LILABEL_MISMATCH;
15722
        LOG_WARN("label is not declared in this scope", K(name), K(label), K(ret));
15723
        LOG_USER_ERROR(OB_ERR_SP_LILABEL_MISMATCH, name.length(), name.ptr());
15724
      } else {
15725
        OZ (SMART_CALL(resolve_label(name, *ns.get_pre_ns(), label, is_iterate_label)));
15726
      }
15727
    }
15728
  }
15729
  return ret;
15730
}
15731

15732
int ObPLResolver::resolve_cond_loop(const ObStmtNodeTree *expr_node, const ObStmtNodeTree *body_node, ObPLCondLoop *stmt, ObPLFunctionAST &func)
15733
{
15734
  int ret = OB_SUCCESS;
15735
  if (OB_ISNULL(expr_node) || OB_ISNULL(body_node) || OB_ISNULL(stmt)) {
15736
    ret = OB_INVALID_ARGUMENT;
15737
    LOG_WARN("parse_tree is NULL", K(expr_node), K(body_node), K(stmt), K(ret));
15738
  } else {
15739
    //解析expr
15740
    ObRawExpr *expr = NULL;
15741
    ObPLDataType data_type(ObTinyIntType);
15742
    if (OB_FAIL(resolve_expr(expr_node, func, expr, combine_line_and_col(expr_node->stmt_loc_),
15743
                             true, &data_type, false, lib::is_mysql_mode()))) {
15744
      LOG_WARN("failed to resolve expr", K(expr_node), K(ret));
15745
    } else {
15746
      stmt->set_cond(func.get_expr_count() - 1);
15747
    }
15748

15749
    //解析body
15750
    if (OB_SUCC(ret)) {
15751
      if (T_SP_PROC_STMT_LIST != body_node->type_) {
15752
        ret = OB_ERR_UNEXPECTED;
15753
        LOG_WARN("Invalid loop body", K(body_node->type_), K(ret));
15754
      } else {
15755
        ObPLStmtBlock *body_block = NULL;
15756
        if (OB_FAIL(resolve_stmt_list(body_node, body_block, func))) {
15757
          LOG_WARN("failed to resolve stmt list", K(body_node->type_), K(ret));
15758
        } else {
15759
          stmt->set_body(body_block);
15760
        }
15761
      }
15762
    }
15763
  }
15764
  return ret;
15765
}
15766

15767
int ObPLResolver::resolve_package_stmt_list(const ObStmtNodeTree *node, ObPLStmtBlock *&block, ObPLPackageAST &package)
15768
{
15769
  int ret = OB_SUCCESS;
15770
  ObPLStmt *stmt = NULL;
15771
  ObPLStmtBlock *parent = current_block_;
15772
  block = NULL;
15773
  if (OB_FAIL(stmt_factory_.allocate(PL_BLOCK, parent, stmt))) {
15774
    LOG_WARN("failed to alloc stmt", K(ret));
15775
  } else if (OB_ISNULL(block = static_cast<ObPLStmtBlock*>(stmt))) {
15776
    ret = OB_ERR_UNEXPECTED;
15777
    LOG_WARN("failed to static cast", K(ret));
15778
  } else if (OB_ISNULL(node)) {
15779
    ret = OB_ERR_UNEXPECTED;
15780
    LOG_WARN("failed to allocate block", K(node), K(block), K(ret));
15781
  } else {
15782
    block->get_namespace().set_symbol_table(&package.get_symbol_table());
15783
    block->get_namespace().set_type_table(&package.get_user_type_table());
15784
    block->get_namespace().set_condition_table(&package.get_condition_table());
15785
    block->get_namespace().set_cursor_table(&package.get_cursor_table());
15786
    block->get_namespace().set_routine_table(&package.get_routine_table());
15787
    block->get_namespace().set_external_ns(&get_external_ns());
15788
    block->get_namespace().set_pre_ns(NULL == parent ? NULL : &parent->get_namespace());
15789
    set_current(*block);
15790

15791
//    for (int64_t i = 0; OB_SUCC(ret) && i < node->num_child_; ++i) {
15792
//      if (NULL != node->children_[i] && OB_FAIL(resolve(node->children_[i], package))) {
15793
//        LOG_WARN("failed to resolve child stmt", K(i), K(node), K(ret));
15794
//      }
15795
//    }
15796

15797
    if (OB_SUCC(ret)) {
15798
      set_current(*parent);
15799
    }
15800
  }
15801
  return ret;
15802
}
15803

15804
int ObPLResolver::resolve_stmt_list(const ObStmtNodeTree *node,
15805
                                    ObPLStmtBlock *&block,
15806
                                    ObPLFunctionAST &func,
15807
                                    bool stop_search_label,
15808
                                    bool in_handler_scope)
15809
{
15810
  int ret = OB_SUCCESS;
15811
  ObPLStmtBlock *parent = current_block_;
15812
  if (OB_ISNULL(node)) {
15813
    ret = OB_ERR_UNEXPECTED;
15814
    LOG_WARN("stmt list node is null", K(ret), K(node));
15815
  } else if (OB_ISNULL(block)
15816
            && OB_FAIL(make_block(func, parent, block, T_SP_BLOCK_CONTENT == node->type_))) {
15817
    LOG_WARN("failed to make block", K(current_block_), K(ret));
15818
  } else if (OB_ISNULL(block)) {
15819
    ret = OB_ERR_UNEXPECTED;
15820
    LOG_WARN("failed to allocate block", K(block), K(ret));
15821
  } else if (stop_search_label && !is_oracle_mode()) {
15822
    block->get_namespace().set_stop_search_label();
15823
  }
15824
  if (OB_SUCC(ret) && in_handler_scope) {
15825
    block->set_handler();
15826
  }
15827

15828
  if (OB_SUCC(ret)) {
15829
    set_current(*block);
15830
    if (T_SP_BLOCK_CONTENT == node->type_) {
15831
      CK (node->num_child_ <= 2 && node->num_child_ >= 1);
15832
      if (OB_SUCC(ret)) {
15833
        RESOLVE_CHILDREN(node->children_[0], func);
15834
      }
15835
      if (OB_SUCC(ret) && 2 == node->num_child_) {
15836
        RESOLVE_CHILDREN(node->children_[1], func);
15837
      }
15838
    } else {
15839
      RESOLVE_CHILDREN(node, func);
15840
    }
15841
    if (OB_SUCC(ret)) {
15842
      set_current(*parent);
15843
    } else if (block != NULL) {
15844
      block->reset();
15845
    }
15846
  }
15847
  return ret;
15848
}
15849

15850
int ObPLResolver::make_block(
15851
  ObPLFunctionAST &func, const ObPLStmtBlock *parent, ObPLStmtBlock *&block, bool explicit_block)
15852
{
15853
  int ret = OB_SUCCESS;
15854
  bool replace_current = block == current_block_;
15855
  ObPLStmt *stmt = NULL;
15856
  if (OB_FAIL(stmt_factory_.allocate(PL_BLOCK, parent, stmt))) {
15857
    LOG_WARN("failed to alloc stmt", K(ret));
15858
  } else if (OB_ISNULL(block = static_cast<ObPLStmtBlock*>(stmt))) {
15859
    ret = OB_ERR_UNEXPECTED;
15860
    LOG_WARN("failed to static cast", K(block), K(ret));
15861
  } else {
15862
    block->get_namespace().set_symbol_table(&func.get_symbol_table());
15863
    block->get_namespace().set_label_table(&func.get_label_table());
15864
    block->get_namespace().set_type_table(&func.get_user_type_table());
15865
    block->get_namespace().set_condition_table(&func.get_condition_table());
15866
    block->get_namespace().set_cursor_table(&func.get_cursor_table());
15867
    block->get_namespace().set_routine_table(&func.get_routine_table());
15868
    block->get_namespace().set_exprs(&func.get_exprs());
15869
    block->get_namespace().set_obj_access_exprs(&func.get_obj_access_exprs());
15870
    block->get_namespace().set_external_ns(&get_external_ns());
15871
    block->get_namespace().set_pre_ns(NULL == parent ? NULL : &parent->get_namespace());
15872
    block->get_namespace().set_block_type(ObPLBlockNS::BLOCK_ROUTINE);
15873
    block->get_namespace().set_db_name(func.get_db_name());
15874
    block->get_namespace().set_database_id(func.get_database_id());
15875
    block->get_namespace().set_package_name(func.get_package_name());
15876
    block->get_namespace().set_package_id(func.get_package_id());
15877
    block->get_namespace().set_package_version(func.get_package_version());
15878
    block->get_namespace().set_routine_id(func.get_subprogram_id());
15879
    block->get_namespace().set_routine_name(func.get_name());
15880
    block->get_namespace().set_compile_flag(func.get_compile_flag());
15881
    if (explicit_block) {
15882
      block->get_namespace().set_explicit_block();
15883
    }
15884
    if (func.is_function()) {
15885
      block->get_namespace().set_function_block();
15886
    }
15887
    if (func.is_udt_routine()) {
15888
      block->get_namespace().set_is_udt_routine();
15889
    }
15890
    if (replace_current) {
15891
      resolve_ctx_.params_.secondary_namespace_ = &block->get_namespace();
15892
    }
15893
    if (NULL != parent) {
15894
      parent->in_notfound() ? block->set_notfound() :  (void)NULL;
15895
      parent->in_warning() ? block->set_warning() :  (void)NULL;
15896
      parent->in_handler() ? block->set_handler() : (void)NULL;
15897
    }
15898
    if (lib::is_oracle_mode()
15899
        && NULL != parent
15900
        && NULL == parent->get_namespace().get_pre_ns()
15901
        && func.get_arg_count() > 0) {
15902
      OV (func.get_arg_count() == block->get_namespace().get_symbol_table()->get_count(),
15903
          OB_ERR_UNEXPECTED, func.get_arg_count(),
15904
          block->get_namespace().get_symbol_table()->get_count());
15905
      for (int i = 0; OB_SUCC(ret) && i < func.get_arg_count(); ++i) {
15906
        OZ (block->get_namespace().get_symbols().push_back(i));
15907
      }
15908
    }
15909
  }
15910
  return ret;
15911
}
15912

15913
int ObPLResolver::make_block(ObPLPackageAST &package_ast, ObPLStmtBlock *&block)
15914
{
15915
  int ret = OB_SUCCESS;
15916
  ObPLStmt *stmt = NULL;
15917
  if (OB_FAIL(stmt_factory_.allocate(PL_BLOCK, NULL, stmt))) {
15918
    LOG_WARN("failed to alloc stmt", K(ret));
15919
  } else if (OB_ISNULL(block = static_cast<ObPLStmtBlock*>(stmt))) {
15920
    ret = OB_ERR_UNEXPECTED;
15921
    LOG_WARN("failed to allocate block", K(block), K(ret));
15922
  } else {
15923
    block->get_namespace().set_symbol_table(&package_ast.get_symbol_table());
15924
    block->get_namespace().set_label_table(&package_ast.get_label_table());
15925
    block->get_namespace().set_type_table(&package_ast.get_user_type_table());
15926
    block->get_namespace().set_condition_table(&package_ast.get_condition_table());
15927
    block->get_namespace().set_cursor_table(&package_ast.get_cursor_table());
15928
    block->get_namespace().set_routine_table(&package_ast.get_routine_table());
15929
    block->get_namespace().set_exprs(&package_ast.get_exprs());
15930
    block->get_namespace().set_obj_access_exprs(&package_ast.get_obj_access_exprs());
15931
    block->get_namespace().set_external_ns(&get_external_ns());
15932
    block->get_namespace().set_block_type(NULL == get_external_ns().get_parent_ns() ?
15933
    package_ast.is_package() ? ObPLBlockNS::BLOCK_PACKAGE_SPEC : ObPLBlockNS::BLOCK_OBJECT_SPEC :
15934
    package_ast.is_package() ? ObPLBlockNS::BLOCK_PACKAGE_BODY : ObPLBlockNS::BLOCK_OBJECT_BODY);
15935
    block->get_namespace().set_db_name(package_ast.get_db_name());
15936
    block->get_namespace().set_database_id(package_ast.get_database_id());
15937
    block->get_namespace().set_package_name(package_ast.get_name());
15938
    block->get_namespace().set_package_id(package_ast.get_id());
15939
    block->get_namespace().set_package_version(package_ast.get_version());
15940
  }
15941
  return ret;
15942
}
15943

15944
int ObPLResolver::replace_record_member_default_expr(ObRawExpr *&expr)
15945
{
15946
  int ret = OB_SUCCESS;
15947
  CK (OB_NOT_NULL(current_block_));
15948
  CK (OB_NOT_NULL(expr));
15949
  if (OB_FAIL(ret)) {
15950
  } else if (T_QUESTIONMARK == expr->get_expr_type()) {
15951
    ObConstRawExpr *const_expr = static_cast<ObConstRawExpr *>(expr);
15952
    ObRawExpr *subprogram_expr = NULL;
15953
    CK (OB_NOT_NULL(const_expr));
15954
    OZ (ObRawExprUtils::build_get_subprogram_var(expr_factory_,
15955
                                                 current_block_->get_namespace().get_package_id(),
15956
                                                 current_block_->get_namespace().get_routine_id(),
15957
                                                 const_expr->get_value().get_unknown(),
15958
                                                 &expr->get_result_type(),
15959
                                                 subprogram_expr,
15960
                                                 &resolve_ctx_.session_info_));
15961
    CK (OB_NOT_NULL(subprogram_expr));
15962
    OX (expr = subprogram_expr);
15963
  } else if (expr->is_obj_access_expr()) {
15964
    ObObjAccessRawExpr *obj_expr = static_cast<ObObjAccessRawExpr *>(expr);
15965
    ObRawExpr *subprogram_expr = NULL;
15966
    ObRawExpr *new_obj_expr = NULL;
15967
    ObIArray<ObObjAccessIdx> &access_idxs = obj_expr->get_orig_access_idxs();
15968
    bool need_rebuild = false;
15969
    for (int64_t i = 0; OB_SUCC(ret) && i < access_idxs.count(); ++i) {
15970
      if (ObObjAccessIdx::IS_LOCAL == access_idxs.at(i).access_type_) {
15971
        ObExprResType *result_type = NULL;
15972
        OZ (convert_pltype_to_restype(expr_factory_.get_allocator(), access_idxs.at(i).var_type_, result_type));
15973
        OZ (ObRawExprUtils::build_get_subprogram_var(expr_factory_,
15974
                                                     current_block_->get_namespace().get_package_id(),
15975
                                                     current_block_->get_namespace().get_routine_id(),
15976
                                                     access_idxs.at(i).var_index_,
15977
                                                     result_type,
15978
                                                     subprogram_expr,
15979
                                                     &resolve_ctx_.session_info_));
15980
        CK (OB_NOT_NULL(subprogram_expr));
15981
        OX (access_idxs.at(i).access_type_ = ObObjAccessIdx::IS_SUBPROGRAM_VAR);
15982
        OX (access_idxs.at(i).get_sysfunc_ = subprogram_expr);
15983
        OX (need_rebuild = true);
15984
      }
15985
    }
15986
    if (OB_SUCC(ret) && need_rebuild) {
15987
      OZ (make_var_from_access(access_idxs,
15988
                               expr_factory_,
15989
                               &(resolve_ctx_.session_info_),
15990
                               &(resolve_ctx_.schema_guard_),
15991
                               current_block_->get_namespace(),
15992
                               new_obj_expr));
15993
      CK (OB_NOT_NULL(new_obj_expr));
15994
      OX (expr = new_obj_expr);
15995
    }
15996
  }
15997
  if (OB_SUCC(ret) && expr->get_expr_type() != T_OP_GET_SUBPROGRAM_VAR) {
15998
    for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
15999
      OZ (SMART_CALL(replace_record_member_default_expr(expr->get_param_expr(i))));
16000
    }
16001
  }
16002
  return ret;
16003
}
16004

16005
int ObPLResolver::check_param_default_expr_legal(ObRawExpr *expr, bool is_subprogram_expr)
16006
{
16007
  int ret = OB_SUCCESS;
16008
  int64_t symbol_idx = OB_INVALID_INDEX;
16009
  CK (OB_NOT_NULL(current_block_));
16010
  CK (OB_NOT_NULL(expr));
16011

16012
  if (OB_FAIL(ret)) {
16013
  } else if (T_QUESTIONMARK == expr->get_expr_type()) {
16014
    ObConstRawExpr *const_expr = static_cast<ObConstRawExpr *>(expr);
16015
    CK (OB_NOT_NULL(const_expr));
16016
    OX (symbol_idx = const_expr->get_value().get_unknown());
16017
  } else if (expr->is_obj_access_expr()) {
16018
    ObObjAccessRawExpr *obj_expr = static_cast<ObObjAccessRawExpr *>(expr);
16019
    ObIArray<ObObjAccessIdx> &access_idxs = obj_expr->get_access_idxs();
16020
    if (ObObjAccessIdx::is_local_variable(access_idxs)) {
16021
      int64_t var_idx = OB_INVALID_INDEX;
16022
      CK (ObObjAccessIdx::get_local_variable_idx(access_idxs) >= 0
16023
          && ObObjAccessIdx::get_local_variable_idx(access_idxs) < access_idxs.count());
16024
      OX (var_idx = access_idxs.at(ObObjAccessIdx::get_local_variable_idx(access_idxs)).var_index_);
16025
      CK (var_idx >= 0 && var_idx < obj_expr->get_var_indexs().count());
16026
      OX (symbol_idx = obj_expr->get_var_indexs().at(var_idx));
16027
    }
16028
  }
16029
  if (OB_SUCC(ret) && symbol_idx != OB_INVALID_INDEX) {
16030
    ObIArray<int64_t> &symbols = current_block_->get_namespace().get_symbols();
16031
    ObString var_name;
16032
    int64_t i = 0;
16033
    for (; i < symbols.count(); ++i) {
16034
      if (symbol_idx == symbols.at(i)) {
16035
        const ObPLVar *var = current_block_->get_namespace().get_symbol_table()->get_symbol(symbol_idx);
16036
        if (OB_NOT_NULL(var)) {
16037
          var_name = var->get_name();
16038
        }
16039
        break;
16040
      }
16041
    }
16042
    if (i == symbols.count()) {
16043
      // not found, do nothing ...
16044
    } else if (i == (symbols.count() - 1)) {
16045
      // default expr refrence self parameter.
16046
      ret = OB_ERR_TYPE_DECL_MALFORMED;
16047
      LOG_WARN(
16048
        "PLS-00320: the declaration of the type of this expression is incomplete or malformed",
16049
        K(symbols), K(symbol_idx), K(ret));
16050
    } else if (is_subprogram_expr) {
16051
      ret = OB_ERR_IN_FORMAL_NOT_DENOTABLE;
16052
      LOG_WARN(
16053
        "PLS-00227: subprogram 'in' formal X is not yet denotable",
16054
        K(symbols), K(symbol_idx), K(ret));
16055
      LOG_USER_ERROR(OB_ERR_IN_FORMAL_NOT_DENOTABLE, var_name.length(), var_name.ptr());
16056
    } else {
16057
      ret = OB_ERR_FIELD_NOT_DENOTABLE;
16058
      LOG_WARN(
16059
        "PLS-00742: field string is not yet denotable", K(symbols), K(symbol_idx), K(ret));
16060
      LOG_USER_ERROR(OB_ERR_FIELD_NOT_DENOTABLE, var_name.length(), var_name.ptr());
16061
    }
16062
  }
16063

16064
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
16065
    OZ (SMART_CALL(check_param_default_expr_legal(expr->get_param_expr(i), is_subprogram_expr)));
16066
  }
16067

16068
  return ret;
16069
}
16070

16071
int ObPLResolver::resolve_routine_decl_param_list(const ParseNode *param_list,
16072
                                                  ObPLCompileUnitAST &unit_ast,
16073
                                                  ObPLRoutineInfo &routine_info)
16074
{
16075
  int ret = OB_SUCCESS;
16076
  if (OB_ISNULL(param_list)) {
16077
    ret = OB_ERR_UNEXPECTED;
16078
    LOG_WARN("param list invalid", K(ret));
16079
  } else if (param_list->type_ != T_SP_PARAM_LIST || OB_ISNULL(param_list->children_)) {
16080
    ret = OB_ERR_UNEXPECTED;
16081
    LOG_WARN("param list type is invalid", K(param_list->type_), K(param_list->children_), K(ret));
16082
  } else if (param_list->num_child_ > OB_MAX_PROC_PARAM_COUNT) {
16083
    ret = OB_NOT_SUPPORTED;
16084
    LOG_WARN("too many formal parameters, max number of formal parameters"
16085
             "in an explicit cursor, function, or procedure is 65536!",
16086
             K(ret), K(OB_MAX_PROC_PARAM_COUNT));
16087
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "number of formal parameters large than 65536");
16088
  } else {
16089
    ObString param_name, default_value;
16090
    ObPLDataType param_type;
16091
    ObPLRoutineParamMode param_mode = PL_PARAM_INVALID;
16092
    ObPLExternTypeInfo extern_type_info;
16093
    bool default_cast = false;
16094

16095
    ObPLStmtBlock *parent = current_block_;
16096
    ObPLBlockNS *parent_namespace = resolve_ctx_.params_.secondary_namespace_;
16097
    ObPLStmtBlock *block = NULL;
16098
    if (unit_ast.is_routine()) {
16099
      OZ (make_block(static_cast<ObPLFunctionAST&>(unit_ast), parent, block, false));
16100
    } else {
16101
      OZ (make_block(static_cast<ObPLPackageAST&>(unit_ast), block));
16102
      OX (block->get_namespace().set_block_type(ObPLBlockNS::BLOCK_ROUTINE));
16103
      OX (block->get_namespace().set_pre_ns(NULL == parent ? NULL : &parent->get_namespace()));
16104
    }
16105
    OX (set_current(*block));
16106

16107
    for (int64_t i = 0; OB_SUCC(ret) && i < param_list->num_child_; ++i) {
16108
      const ParseNode *param_node = param_list->children_[i];
16109
      const ParseNode *name_node = NULL;
16110
      const ParseNode *type_node = NULL;
16111
      param_name.reset();
16112
      default_value.reset();
16113
      default_cast = false;
16114
      param_type.reset();
16115
      extern_type_info.reset();
16116
      if (OB_ISNULL(param_node)
16117
          || OB_UNLIKELY(param_node->type_ != T_SP_PARAM)
16118
          || OB_ISNULL(param_node->children_)) {
16119
        ret = OB_ERR_UNEXPECTED;
16120
        LOG_WARN("param node is invalide", K(param_node), K_(param_node->children));
16121
      } else if (OB_ISNULL(name_node = param_node->children_[0])
16122
          || OB_ISNULL(type_node = param_node->children_[1])) {
16123
        ret = OB_ERR_UNEXPECTED;
16124
        LOG_WARN("name node or type node is null", K(name_node), K(type_node));
16125
      } else {
16126
        param_name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));
16127
        bool with_rowid = check_with_rowid(routine_info.get_name(),
16128
                                           resolve_ctx_.session_info_.is_for_trigger_package());
16129
        if (OB_FAIL(resolve_sp_data_type(type_node, param_name, unit_ast,
16130
                                         param_type, &extern_type_info, with_rowid, true))) {
16131
          LOG_WARN("resolve data type failed", K(ret), K(param_name));
16132
        } else {
16133
          switch (param_node->int32_values_[0]) {
16134
          case MODE_IN:
16135
            param_mode = PL_PARAM_IN;
16136
            break;
16137
          case MODE_OUT:
16138
            param_mode = PL_PARAM_OUT;
16139
            if (!unit_ast.is_package()) {
16140
              unit_ast.set_has_out_param();
16141
            }
16142
            break;
16143
          case MODE_INOUT:
16144
            param_mode = PL_PARAM_INOUT;
16145
            if (!unit_ast.is_package()) {
16146
              unit_ast.set_has_out_param();
16147
            }
16148
            break;
16149
          default:
16150
            ret = OB_ERR_UNEXPECTED;
16151
            LOG_WARN("param inout flag is invalid", K(param_node->value_));
16152
            break;
16153
          }
16154
        }
16155
        // clear warning info while type is self, only in object spec resolve
16156
        if (OB_SUCC(ret) && routine_info.is_udt_routine()
16157
          && 0 == current_block_->get_namespace().get_package_name().case_compare(extern_type_info.type_name_)) {
16158
          OX (ob_reset_tsi_warning_buffer());
16159
        }
16160
        OZ (current_block_->get_namespace().add_symbol(param_name, param_type, NULL,
16161
                                                      false, false, false, true));
16162
        if (OB_ERR_SP_DUP_VAR == ret) {
16163
          ret = OB_ERR_DUPLICATE_FILED;
16164
        }
16165
        if (OB_SUCC(ret)  // mysql mode 没有param_node->children_[2]
16166
            && OB_NOT_NULL(param_node->children_[2])
16167
            && (PL_PARAM_OUT == param_mode || PL_PARAM_INOUT == param_mode)) {
16168
          ret = OB_ERR_OUT_PARAM_HAS_DEFAULT;
16169
          LOG_WARN("PLS-00230: OUT and IN OUT formal parameters may not have default expressions",
16170
                   K(ret));
16171
        }
16172
        if (OB_SUCC(ret) && OB_NOT_NULL(param_node->children_[2])) {
16173
          ParseNode* default_node = param_node->children_[2];
16174
          ObString default_v(static_cast<int32_t>(default_node->str_len_),
16175
                             default_node->str_value_);
16176
          ObRawExpr *default_expr = NULL;
16177
          ObRoutineMatchInfo::MatchInfo match_info;
16178
          ObObjType src_type = ObMaxType;
16179
          uint64_t src_type_id = OB_INVALID_ID;
16180
          CK (T_SP_DECL_DEFAULT == default_node->type_);
16181
          CK (!default_v.empty());
16182
          OZ (resolve_expr(default_node->children_[0], unit_ast, default_expr,
16183
                           combine_line_and_col(default_node->children_[0]->stmt_loc_), false));
16184
          OZ (ObResolverUtils::get_type_and_type_id(default_expr, src_type, src_type_id));
16185
          OZ (ObResolverUtils::check_type_match(
16186
            resolve_ctx_, match_info, default_expr, src_type, src_type_id, param_type));
16187
          CK (OB_NOT_NULL(default_expr));
16188
          OZ (check_param_default_expr_legal(default_expr));
16189
          OX (default_value = default_v);
16190
          OX (default_cast = match_info.need_cast_);
16191
        }
16192
        if (OB_SUCC(ret)) {
16193
          ObPLRoutineParam *param = NULL;
16194
          bool is_nocopy = is_mysql_mode() ? false : (1 == param_node->int32_values_[1]);
16195
          OZ (routine_info.make_routine_param(resolve_ctx_.allocator_,
16196
                                              resolve_ctx_.session_info_.get_dtc_params(),
16197
                                              param_name,
16198
                                              param_type,
16199
                                              param_mode,
16200
                                              is_nocopy, //nocopy
16201
                                              default_value,
16202
                                              default_cast,
16203
                                              extern_type_info,
16204
                                              param));
16205
          if (OB_SUCC(ret) && OB_NOT_NULL(param)) {
16206
            // make sure self param' type is object's type
16207
            if (param->is_self_param()) {
16208
              const ObPLBlockNS *top_ns = &(current_block_->get_namespace());
16209
              CK (OB_NOT_NULL(top_ns));
16210
              int64_t cnt = 0;
16211
              while (OB_SUCC(ret) && OB_NOT_NULL(top_ns->get_pre_ns())) {
16212
                top_ns = top_ns->get_pre_ns();
16213
                ++cnt;
16214
                if (10000 < cnt) {
16215
                  break;
16216
                }
16217
              };
16218
              if (10000 == cnt) {
16219
                ret = OB_ERR_UNEXPECTED;
16220
                LOG_WARN("seems infinite recursive loop, loop iterations: ", K(cnt));
16221
              }
16222
              if (OB_SUCC(ret)) {
16223
                if (ObPLBlockNS::BlockType::BLOCK_OBJECT_SPEC == top_ns->get_block_type()
16224
                    || ObPLBlockNS::BlockType::BLOCK_OBJECT_BODY == top_ns->get_block_type()) {
16225
                  const ObString &obj_name = top_ns->get_package_name();
16226
                  if (0 != obj_name.case_compare(param->get_type_name())) {
16227
                    ret = OB_ERR_EXPRESSION_WRONG_TYPE;
16228
                    LOG_WARN("PLS-00382: expression is of wrong type", K(ret), K(obj_name), K(param->get_type_name()));
16229
                    LOG_USER_ERROR(OB_ERR_EXPRESSION_WRONG_TYPE);
16230
                  }
16231
                  if (OB_FAIL(ret)) {
16232
                  } else if (PL_PARAM_OUT == param_mode) {
16233
                    ret = OB_ERR_SELF_PARAM_NOT_OUT;
16234
                    LOG_USER_ERROR(OB_ERR_SELF_PARAM_NOT_OUT);
16235
                  } else if (routine_info.is_udt_cons() && param_mode != PL_PARAM_INOUT) {
16236
                    ret = OB_ERR_SELF_PARAM_NOT_INOUT;
16237
                    LOG_USER_ERROR(OB_ERR_SELF_PARAM_NOT_INOUT);
16238
                  }
16239
                } else {
16240
                  param->set_is_self_param(false);
16241
                }
16242
              }
16243
            }
16244
          }
16245
          OZ (routine_info.add_param(param));
16246
          if (OB_FAIL(ret) && OB_NOT_NULL(param)) {
16247
            param->~ObPLRoutineParam();
16248
            resolve_ctx_.allocator_.free(param);
16249
            param = NULL;
16250
          }
16251
          // bool is_readonly = false;
16252
          // OX (is_readonly = (param->is_self_param() && PL_PARAM_IN == param_mode) ? true : false);
16253
          if (OB_SUCC(ret) && param->is_self_param()) {
16254
            current_block_->get_namespace().get_symbol_table()->set_self_param_idx();
16255
          }
16256
          if (OB_SUCC(ret) && (param->is_self_param() && PL_PARAM_IN == param_mode)) {
16257
            // is_readonly = true;
16258
            const ObPLVar *var=current_block_->get_namespace().get_symbol_table()->get_self_param();
16259
            if (OB_NOT_NULL(var)) {
16260
              const_cast<ObPLVar *>(var)->set_readonly(true);
16261
            }
16262
          }
16263
        }
16264
      }
16265
    }
16266
    if (OB_SUCC(ret) && OB_NOT_NULL(block)) {
16267
      OZ (block->get_namespace().delete_symbols());
16268
    }
16269
    if (OB_NOT_NULL(parent)) {
16270
      set_current(*parent);
16271
      resolve_ctx_.params_.secondary_namespace_ = parent_namespace;
16272
    }
16273
  }
16274
  return ret;
16275
}
16276

16277
int ObPLResolver::check_params_legal_in_body_routine(ObPLFunctionAST &routine_ast,
16278
                                                     const ObPLRoutineInfo *parent_routine_info,
16279
                                                     const ObPLRoutineInfo *body_routine_info)
16280
{
16281
  // 包头中有默认值,包体中可以有默认值也可以没有
16282
  // 如果包体中有默认值, 必须与包头中的默认值一致
16283
  int ret = OB_SUCCESS;
16284
  CK (OB_NOT_NULL(parent_routine_info));
16285
  CK (OB_NOT_NULL(body_routine_info));
16286
  if (OB_SUCC(ret)) {
16287
    const common::ObIArray<ObPLRoutineParam *> &parent_params = parent_routine_info->get_params();
16288
    const common::ObIArray<ObPLRoutineParam *> &body_params = body_routine_info->get_params();
16289
    CK (OB_LIKELY(parent_params.count() == body_params.count()));
16290
    ObArenaAllocator allocator;
16291
    SMART_VAR(ObPLFunctionAST, parent_ast, allocator) {
16292
      for (int64_t i = 0; OB_SUCC(ret) && i < parent_params.count(); ++i) {
16293
        ObPLRoutineParam* parent_param = parent_params.at(i);
16294
        ObPLRoutineParam* body_param = body_params.at(i);
16295
        CK (OB_NOT_NULL(parent_param));
16296
        CK (OB_NOT_NULL(body_param));
16297
        if (OB_SUCC(ret)) {
16298
          const ObPLVar *var = routine_ast.get_symbol_table().get_symbol(i);
16299
          ObPLDataType expected_type(parent_param->get_type().get_obj_type());
16300
          OZ (init_default_expr(parent_ast,
16301
                                *parent_param,
16302
                                var->get_type()));
16303
          if (OB_FAIL(ret)) {
16304
          } else if (!parent_param->get_default_value().empty()) {
16305
            if (body_param->get_default_value().empty()) {
16306
              body_param->set_default_value(parent_param->get_default_value());
16307
              OZ (init_default_expr(routine_ast, i, *body_param));
16308
            } else {
16309
              ObRawExpr* body_default = routine_ast.get_expr(var->get_default());
16310
              ObRawExpr* parent_default = parent_ast.get_expr(parent_ast.get_expr_count()-1);
16311
              ObExprEqualCheckContext check_ctx;
16312
              check_ctx.need_check_deterministic_ = false;
16313
              if (NULL == parent_default || NULL == body_default) {
16314
                ret = OB_ERR_UNEXPECTED;
16315
                LOG_WARN("default expr is null.", K(ret), K(parent_default), K(body_default));
16316
              } else if (!body_default->same_as(*parent_default, &check_ctx)) {
16317
                ret = OB_ERR_DEFAULT_NOT_MATCH;
16318
                LOG_WARN("PLS-00593:"
16319
                        " default value of parameter 'string' in body must match that of spec",
16320
                        K(ret));
16321
              } else { }
16322
            }
16323
          } else if (!body_param->get_default_value().empty()) {
16324
            ret = OB_ERR_DEFAULT_NOT_MATCH;
16325
            LOG_WARN("PLS-00593:"
16326
                    "default value of parameter 'string' in body must match that of spec",
16327
                    K(ret));
16328
          }
16329
        }
16330
      }
16331
    }
16332
  }
16333
  return ret;
16334
}
16335

16336
int ObPLResolver::resolve_routine_decl(const ObStmtNodeTree *parse_tree,
16337
                                       ObPLCompileUnitAST &unit_ast,
16338
                                       ObPLRoutineInfo *&routine_info,
16339
                                       bool is_udt_routine,
16340
                                       bool resolve_routine_def)
16341
{
16342
  int ret = OB_SUCCESS;
16343
  CK (T_SUB_PROC_DECL == parse_tree->type_ || T_SUB_FUNC_DECL == parse_tree->type_);
16344
  CK (OB_NOT_NULL(parse_tree->str_value_),
16345
      OB_NOT_NULL(parse_tree->children_),
16346
      OB_LIKELY(parse_tree->num_child_ <= 5));
16347
  routine_info = NULL;
16348
  if (OB_SUCC(ret)) {
16349
    ObString routine_name;
16350
    ObArray<int64_t> dummy_path;
16351
    ObPLDataType ret_type;
16352
    /* A subprogram created inside a package is a packaged subprogram .
16353
     *  A subprogram created inside a PL/SQL block is a nested subprogram */
16354
    ObProcType routine_type = unit_ast.is_package() || unit_ast.is_object()
16355
        ? ((T_SUB_PROC_DECL == parse_tree->type_) ? PACKAGE_PROCEDURE : PACKAGE_FUNCTION)
16356
            : ((T_SUB_PROC_DECL == parse_tree->type_) ? NESTED_PROCEDURE : NESTED_FUNCTION);
16357
    const ObPLRoutineTable *routine_table = NULL;
16358
    ObString routine_decl_str(static_cast<int32_t>(parse_tree->str_len_), parse_tree->str_value_);
16359
    CK (OB_NOT_NULL(parse_tree->children_[0]));
16360
    CK (OB_LIKELY(T_IDENT == parse_tree->children_[0]->type_));
16361
    OX (routine_name.assign_ptr(parse_tree->children_[0]->str_value_,
16362
                                static_cast<int32_t>(parse_tree->children_[0]->str_len_)));
16363
    if (OB_UNLIKELY(routine_name.length() > 
16364
      (lib::is_oracle_mode() ? OB_MAX_PL_IDENT_LENGTH : OB_MAX_MYSQL_PL_IDENT_LENGTH))) {
16365
      ret = OB_ERR_IDENTIFIER_TOO_LONG;
16366
      LOG_USER_ERROR(OB_ERR_IDENTIFIER_TOO_LONG, routine_name.length(), routine_name.ptr());
16367
      LOG_WARN("identifier too long", K(routine_name), K(ret));
16368
    }
16369
    CK (OB_NOT_NULL(routine_table = current_block_->get_namespace().get_routine_table()));
16370
    OZ (routine_table->make_routine_info(resolve_ctx_.allocator_,
16371
                                         routine_name,
16372
                                         routine_type,
16373
                                         routine_decl_str,
16374
                                         unit_ast.get_database_id(),
16375
                                         unit_ast.is_package() || unit_ast.is_object() ? unit_ast.get_id() : static_cast<ObPLFunctionAST&>(unit_ast).get_package_id(),
16376
                                         unit_ast.is_package() || unit_ast.is_object() ? OB_INVALID_ID : static_cast<ObPLFunctionAST&>(unit_ast).get_id(),
16377
                                         unit_ast.is_package() || unit_ast.is_object()
16378
                                           ? dummy_path : static_cast<ObPLFunctionAST&>(unit_ast).get_subprogram_path(),
16379
                                         routine_info));
16380
    if (OB_SUCC(ret) && unit_ast.get_priv_user().length() != 0) {
16381
      routine_info->set_priv_user(unit_ast.get_priv_user());
16382
    }
16383
    if (OB_SUCC(ret) && is_udt_routine) {
16384
      routine_info->set_is_udt_routine();
16385
      int64_t udt_udf_modifier = static_cast<int64_t>(parse_tree->int16_values_[0]);
16386
      if (UdtUdfType::UDT_UDF_STATIC == udt_udf_modifier) {
16387
        routine_info->get_compile_flag().add_static();
16388
      } else if (UdtUdfType::UDT_UDF_MAP == udt_udf_modifier) {
16389
        if (routine_info->is_function()) {
16390
          routine_info->get_compile_flag().add_map();
16391
        } else {
16392
          ret = OB_ERR_ORDER_MAP_NEED_BE_FUNC;
16393
          LOG_WARN("Only a function may be a MAP, ORDER or CONSTRUCTOR method",
16394
                       K(ret), KPC(routine_info));
16395
        }
16396
      } else if (UdtUdfType::UDT_UDF_ORDER == udt_udf_modifier) {
16397
        if (routine_info->is_function()) {
16398
          routine_info->get_compile_flag().add_order();
16399
        } else {
16400
          ret = OB_ERR_ORDER_MAP_NEED_BE_FUNC;
16401
          LOG_WARN("Only a function may be a MAP, ORDER or CONSTRUCTOR method",
16402
                       K(ret), KPC(routine_info));
16403
        }
16404
      } else if (UdtUdfType::UDT_UDF_CONS == udt_udf_modifier) {
16405
        routine_info->set_is_udt_cons();
16406
        if (0 != routine_info->get_name().case_compare(
16407
          current_block_->get_namespace().get_package_name())) {
16408
          ret = OB_ERR_CONS_NAME_ILLEGAL;
16409
          LOG_USER_ERROR(OB_ERR_CONS_NAME_ILLEGAL);
16410
        }
16411
      } else {
16412
        // do nothing
16413
        if (!routine_info->is_udt_cons()
16414
        && 0 == routine_info->get_name().case_compare(
16415
           current_block_->get_namespace().get_package_name())) {
16416
          ret = OB_ERR_FUNC_NAME_SAME_WITH_CONS;
16417
          LOG_WARN("not construtor but name is same as type name", K(ret));
16418
          LOG_USER_ERROR(OB_ERR_FUNC_NAME_SAME_WITH_CONS, routine_info->get_name().length(),
16419
                                                          routine_info->get_name().ptr());
16420
        }
16421
      }
16422
    }
16423
    if (OB_SUCC(ret) && (PACKAGE_FUNCTION == routine_type || NESTED_FUNCTION == routine_type)) {
16424
      ParseNode *type_node = parse_tree->children_[2];
16425
      ObPLRoutineParam *param = NULL;
16426
      ObPLExternTypeInfo extern_type_info;
16427
      CK (OB_NOT_NULL(type_node));
16428
      OZ (resolve_sp_data_type(type_node, ObString(""), unit_ast, ret_type, &extern_type_info));
16429
      // clear warning info while type is self, only in object spec resolve
16430
      if (OB_SUCC(ret) && routine_info->is_udt_routine()
16431
        && 0 == current_block_->get_namespace().get_package_name().case_compare(extern_type_info.type_name_)) {
16432
        OX (ob_reset_tsi_warning_buffer());
16433
      }
16434
      OZ (routine_info->make_routine_param(resolve_ctx_.allocator_,
16435
                                           resolve_ctx_.session_info_.get_dtc_params(),
16436
                                           ObString(""),
16437
                                           ret_type,
16438
                                           PL_PARAM_OUT,
16439
                                           false, //nocopy
16440
                                           ObString(""),
16441
                                           false, //default cast
16442
                                           extern_type_info,
16443
                                           param));
16444
      OX (routine_info->set_ret_info(param));
16445
      OX ((ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY == current_block_->get_namespace().get_block_type()
16446
          || ObPLBlockNS::BlockType::BLOCK_OBJECT_BODY == current_block_->get_namespace().get_block_type())
16447
            ? routine_info->set_is_private_routine() : void());
16448
    }
16449
    if (OB_SUCC(ret)) {
16450
      const ObObjMeta *meta = ret_type.get_meta_type();
16451
      // check map return type
16452
      if (routine_info->is_udt_map()
16453
      && (ret_type.is_rowtype_type()
16454
          || ret_type.is_type_type()
16455
          || ret_type.is_boolean_type()
16456
          || ret_type.is_urowid_type()
16457
          // || ret_type.is_long_type()
16458
          || ret_type.is_lob_type()
16459
          || ret_type.is_lob_storage_type()))
16460
      {
16461
        ret = OB_ERR_MAP_RET_SCALAR_TYPE;
16462
        LOG_USER_ERROR(OB_ERR_MAP_RET_SCALAR_TYPE);
16463
      }
16464
      if (routine_info->is_udt_order()
16465
      && (ret_type.is_rowtype_type()
16466
         || ret_type.is_type_type()
16467
         || ret_type.is_boolean_type()
16468
         || ret_type.is_real_type())) {
16469
        ret = OB_ERR_ORDER_RET_INT_TYPE;
16470
        LOG_USER_ERROR(OB_ERR_ORDER_RET_INT_TYPE);
16471
      }
16472
    }
16473
    if (OB_SUCC(ret) && OB_NOT_NULL(parse_tree->children_[1])) {
16474
      CK (OB_LIKELY(T_SP_PARAM_LIST == parse_tree->children_[1]->type_));
16475
      OZ (resolve_routine_decl_param_list(parse_tree->children_[1], unit_ast, *routine_info));
16476
    }
16477
    const ObStmtNodeTree *clause_node = NULL;
16478
    if (OB_SUCC(ret)
16479
        && T_SUB_FUNC_DECL == parse_tree->type_
16480
        && 5 == parse_tree->num_child_
16481
        && OB_NOT_NULL(parse_tree->children_[3])) {
16482
      OZ (resolve_sf_clause(
16483
        parse_tree->children_[3], routine_info, routine_type, ret_type));
16484
      OX (clause_node = parse_tree->children_[3]);
16485
    }
16486
    if (OB_SUCC(ret)
16487
        && T_SUB_PROC_DECL == parse_tree->type_
16488
        && 3 == parse_tree->num_child_
16489
        && OB_NOT_NULL(parse_tree->children_[2])) {
16490
      OZ (resolve_sf_clause(
16491
        parse_tree->children_[2], routine_info, routine_type, ret_type));
16492
      OX (clause_node = parse_tree->children_[2]);
16493
    }
16494
    if (OB_SUCC(ret) && routine_info->has_accessible_by_clause()) {
16495
      for (int64_t i = 0;
16496
           OB_SUCC(ret) && OB_NOT_NULL(clause_node) && i < clause_node->num_child_; ++i) {
16497
        const ObStmtNodeTree *child = clause_node->children_[i];
16498
        if (OB_NOT_NULL(child) && T_SP_ACCESSIBLE_BY == child->type_) {
16499
          const ObStmtNodeTree *accessor_list = NULL;
16500
          CK (1 == child->num_child_);
16501
          OX (accessor_list = child->children_[0]);
16502
          CK (OB_NOT_NULL(accessor_list));
16503
          CK (T_SP_ACCESSOR_LIST == accessor_list->type_);
16504
          OZ (resolve_accessible_by(accessor_list, routine_info->get_accessors()));
16505
        }
16506
      }
16507
    }
16508
    if (OB_SUCC(ret) && routine_info->has_generic_type() && resolve_routine_def) {
16509
      ret = OB_NOT_SUPPORTED;
16510
      LOG_WARN("NOTICE: Routine use Generic Type not Implement with Interface not supported",
16511
                K(ret), K(resolve_routine_def), K(routine_info->has_generic_type()));
16512
      LOG_USER_ERROR(OB_NOT_SUPPORTED,
16513
        "NOTICE: Routine use Generic Type not Implement with Interface");
16514
    }
16515
    const ObPLRoutineInfo *exist = NULL;
16516
    OZ (current_block_->get_namespace().get_routine_info(routine_info, exist));
16517
    if (OB_SUCC(ret) && resolve_routine_def) {
16518
      for (int64_t i = 0; OB_SUCC(ret) && i <routine_info->get_param_count(); ++i) {
16519
        if (OB_NOT_NULL(routine_info->get_params().at(i)->get_type().get_data_type())
16520
            && routine_info->get_params().at(i)->get_type().get_data_type()->get_charset_type()
16521
            == CHARSET_ANY) {
16522
          ret = OB_NOT_SUPPORTED;
16523
          LOG_WARN("character set ANY_CS is only supported defined by pragma interface", K(ret));
16524
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "character set ANY_CS defined using method other than pragma interface");
16525
        }
16526
      }
16527
    }
16528
    if (OB_SUCC(ret) && OB_NOT_NULL(exist)) {
16529
      if (resolve_routine_def) {
16530
        ObPLFunctionAST *routine_ast = NULL;
16531
        int64_t idx = OB_INVALID_INDEX;
16532
        OZ (exist->get_idx(idx));
16533
        OZ (routine_table->get_routine_ast(idx, routine_ast));
16534
        if (OB_SUCC(ret) && OB_NOT_NULL(routine_ast)) { // 已经定义过函数体,不可以重复定义
16535
          ret = OB_ERR_EXIST_OBJECT;
16536
          LOG_WARN("already has same routine in package", K(ret));
16537
        }
16538
      } else { // 已经声明过函数,不可以重复声明
16539
        ret = OB_ERR_ATTR_FUNC_CONFLICT;
16540
        LOG_WARN("already has same routine in package", K(ret));
16541
        LOG_USER_ERROR(OB_ERR_ATTR_FUNC_CONFLICT,
16542
                       exist->get_name().length(), exist->get_name().ptr());
16543
      }
16544
    }
16545
    if (OB_SUCC(ret) && NULL == exist) { // 如果已经声明过, 不需要重复加入TABLE
16546
      const ObPLRoutineInfo *parent_routine_info = NULL;
16547
      // NOTICE: only package or object body need search parent_routine_info
16548
      if ((ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY
16549
            == current_block_->get_namespace().get_block_type()
16550
          && OB_NOT_NULL(external_ns_.get_parent_ns())
16551
          && ObPLBlockNS::BlockType::BLOCK_PACKAGE_SPEC
16552
              == external_ns_.get_parent_ns()->get_block_type())
16553
          || (ObPLBlockNS::BlockType::BLOCK_OBJECT_BODY
16554
            == current_block_->get_namespace().get_block_type()
16555
          && OB_NOT_NULL(external_ns_.get_parent_ns())
16556
          && ObPLBlockNS::BlockType::BLOCK_OBJECT_SPEC
16557
              == external_ns_.get_parent_ns()->get_block_type())) {
16558
        OZ (external_ns_.get_parent_ns()->get_routine_info(routine_info, parent_routine_info));
16559
      }
16560
      if (OB_FAIL(ret)) {
16561
      } else if (NULL != parent_routine_info) {  // public routine
16562
        if (parent_routine_info->is_pipelined() != routine_info->is_pipelined()
16563
            || (routine_info->is_deterministic() && !parent_routine_info->is_deterministic())
16564
            || (routine_info->is_parallel_enable() && !parent_routine_info->is_parallel_enable())
16565
            || (routine_info->is_result_cache() && !parent_routine_info->is_result_cache())) {
16566
          ret = OB_ERR_ITEM_NOT_IN_BODY;
16567
          LOG_WARN("PLS-00323: subprogram or cursor is declared"
16568
                   "in a package specification and must be defined in the package body",
16569
                   K(ret), KPC(routine_info), KPC(exist));
16570
        }
16571
        if (OB_SUCC(ret)
16572
            && (routine_info->has_accessible_by_clause()
16573
                  != parent_routine_info->has_accessible_by_clause()
16574
                || !is_array_equal(
16575
                  routine_info->get_accessors(), parent_routine_info->get_accessors()))) {
16576
          ret = OB_ERR_MISMATCH_SUBPROGRAM;
16577
          LOG_WARN("PLS-00263: mismatch between string on a subprogram specification and body",
16578
                   K(ret), KPC(routine_info), KPC(parent_routine_info));
16579
        }
16580
        OX (routine_info->set_compile_flag(parent_routine_info->get_compile_flag()));
16581
        OZ (current_block_->get_namespace().set_routine_info(parent_routine_info->get_id(), routine_info));
16582
      } else { // private routine
16583
        if (resolve_routine_def && routine_info->has_accessible_by_clause()) {
16584
          ret = OB_ERR_MISMATCH_SUBPROGRAM;
16585
          LOG_WARN("PLS-00263: mismatch between string on a subprogram specification and body",
16586
                   K(ret));
16587
        }
16588
        // need set line info
16589
        OX (routine_info->set_loc(combine_line_and_col(parse_tree->stmt_loc_)));
16590
        OZ (current_block_->get_namespace().add_routine_info(routine_info));
16591
      }
16592
    }
16593
    if ((OB_FAIL(ret) && OB_NOT_NULL(routine_info))
16594
        || OB_NOT_NULL(exist)) {
16595
      routine_info->~ObPLRoutineInfo();
16596
      resolve_ctx_.allocator_.free(routine_info);
16597
      routine_info = const_cast<ObPLRoutineInfo*>(exist);
16598
    }
16599
  }
16600
  if (OB_FAIL(ret)) {
16601
    record_error_line(parse_tree, resolve_ctx_.session_info_);
16602
  }
16603
  return ret;
16604
}
16605

16606
int ObPLResolver::resolve_routine_block(const ObStmtNodeTree *parse_tree,
16607
                                        const ObPLRoutineInfo &routine_info,
16608
                                        ObPLFunctionAST &routine_ast)
16609
{
16610
  int ret = OB_SUCCESS;
16611
  const ParseNode *routine_block = parse_tree;
16612
  if (OB_ISNULL(routine_block)) {
16613
    ret = OB_ERR_UNEXPECTED;
16614
    LOG_WARN("routine_block is invalid", K(ret));
16615
  } else {
16616
    ObPLResolver resolver(resolve_ctx_.allocator_, resolve_ctx_.session_info_, resolve_ctx_.schema_guard_,
16617
                          resolve_ctx_.package_guard_, resolve_ctx_.sql_proxy_, expr_factory_,
16618
                          &current_block_->get_namespace(), resolve_ctx_.is_prepare_protocol_,
16619
                          false/*is_check_mode_ = false*/, false/*bool is_sql_scope_ = false*/,
16620
                          resolve_ctx_.params_.param_list_);
16621
    // note: init函数中引用了resolver的external_ns_, 而resolver是一个栈变量，使用的时候需要小心
16622
    if (OB_FAIL(resolver.init(routine_ast))) {
16623
      LOG_WARN("routine init failed ", K(ret));
16624
    } else if (OB_FAIL(resolver.init_default_exprs(routine_ast, routine_info.get_params()))) {
16625
      LOG_WARN("routine init default exprs failed", K(ret));
16626
    } else {
16627
      const ObPLRoutineInfo *parent_routine_info = NULL;
16628
      // NOTICE: only package body need search parent_routine_info
16629
      if ((ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY
16630
            == current_block_->get_namespace().get_block_type()
16631
          && OB_NOT_NULL(external_ns_.get_parent_ns())
16632
          && ObPLBlockNS::BlockType::BLOCK_PACKAGE_SPEC
16633
              == external_ns_.get_parent_ns()->get_block_type())
16634
          || (ObPLBlockNS::BlockType::BLOCK_OBJECT_BODY
16635
            == current_block_->get_namespace().get_block_type()
16636
          && OB_NOT_NULL(external_ns_.get_parent_ns())
16637
          && ObPLBlockNS::BlockType::BLOCK_OBJECT_SPEC
16638
              == external_ns_.get_parent_ns()->get_block_type())) {
16639
        OZ (external_ns_.get_parent_ns()->get_routine_info(&routine_info, parent_routine_info));
16640
      }
16641
      if (NULL != parent_routine_info &&
16642
            OB_FAIL(resolver.check_params_legal_in_body_routine(routine_ast,
16643
                                                                parent_routine_info,
16644
                                                                &routine_info))) {
16645
        LOG_WARN("param ilegal.", K(ret));
16646
      }
16647
    }
16648
    if (OB_SUCC(ret)) {
16649
      if (OB_FAIL(resolver.resolve_root(routine_block, routine_ast))) {
16650
        LOG_WARN("resolve routine block failed", K(routine_block->type_), K(ret));
16651
      } else {
16652
        OX (const_cast<ObPLBlockNS &>(routine_ast.get_body()->get_namespace()).set_external_ns(NULL));
16653
      }
16654
    }
16655
    if (resolve_ctx_.session_info_.is_pl_debug_on()) {
16656
      if (OB_FAIL(routine_ast.generate_symbol_debuginfo())) {
16657
        LOG_WARN("failed to generate symbol debuginfo", K(ret));
16658
      }
16659
    }
16660
  }
16661
  return ret;
16662
}
16663

16664
int ObPLResolver::resolve_routine_def(const ObStmtNodeTree *parse_tree,
16665
                                      ObPLCompileUnitAST &unit_ast,
16666
                                      bool is_udt_routine)
16667
{
16668
  int ret = OB_SUCCESS;
16669
  CK (OB_LIKELY(T_SUB_PROC_DEF == parse_tree->type_ || T_SUB_FUNC_DEF == parse_tree->type_));
16670
  CK (OB_LIKELY(2 == parse_tree->num_child_));
16671
  CK (OB_NOT_NULL(parse_tree->children_));
16672
  CK (OB_NOT_NULL(parse_tree->children_[1]));
16673
  if (OB_SUCC(ret)) {
16674
    ParseNode *routine_decl = parse_tree->children_[0];
16675
    ObPLRoutineInfo *routine_info = NULL;
16676
    ObPLRoutineTable &routine_table = unit_ast.get_routine_table();
16677
    ObPLFunctionAST *routine_ast = NULL;
16678
    ObString route_sql;
16679
    ObString routine_body(
16680
      parse_tree->children_[1]->str_len_, parse_tree->children_[1]->str_value_);
16681
    int64_t idx = OB_INVALID_INDEX;
16682
    OZ (resolve_routine_decl(routine_decl, unit_ast, routine_info, is_udt_routine, true));
16683
    CK (OB_NOT_NULL(routine_info));
16684
    OZ (routine_info->get_idx(idx));
16685
    OZ (routine_table.get_routine_ast(idx, routine_ast));
16686
    if (OB_SUCC(ret) && OB_NOT_NULL(routine_ast)) {
16687
      ret = OB_ERR_SP_DUP_VAR;
16688
      LOG_USER_ERROR(OB_ERR_SP_DUP_VAR,
16689
          routine_ast->get_name().length(), routine_ast->get_name().ptr());
16690
    }
16691
    if (OB_SUCC(ret)) {
16692
      OZ (routine_info->add_compile_flag(unit_ast.get_compile_flag()));
16693
    }
16694
    OZ (routine_table.make_routine_ast(resolve_ctx_.allocator_,
16695
                                       unit_ast.get_db_name(),
16696
                                       (unit_ast.is_package() || unit_ast.is_object())
16697
                                        ? unit_ast.get_name()
16698
                                          : current_block_->get_namespace().get_package_name(),
16699
                                       unit_ast.get_version(),
16700
                                       *routine_info,
16701
                                       routine_ast));
16702
    if (OB_SUCC(ret)) {
16703
      if (unit_ast.is_object()) {
16704
        routine_ast->set_is_udt_routine();
16705
      }
16706
      if (routine_info->is_udt_cons()) {
16707
        routine_ast->set_is_udt_cons();
16708
      }
16709
    }
16710
    OZ (resolve_routine_block(parse_tree->children_[1], *routine_info, *routine_ast));
16711
    OX (routine_ast->get_body()->set_location(
16712
      parse_tree->stmt_loc_.first_line_, parse_tree->stmt_loc_.first_column_));
16713
    OZ (ObPLRouter::analyze_stmt(routine_ast->get_body(), route_sql));
16714
    if (OB_FAIL(ret)) {
16715
    } else if ((ObPLBlockNS::BlockType::BLOCK_PACKAGE_BODY
16716
        == current_block_->get_namespace().get_block_type()
16717
        && OB_NOT_NULL(external_ns_.get_parent_ns())
16718
        && ObPLBlockNS::BlockType::BLOCK_PACKAGE_SPEC
16719
          == external_ns_.get_parent_ns()->get_block_type())) {
16720
        const ObPLRoutineInfo *decl_routine_info = nullptr;
16721
        OZ (external_ns_.get_parent_ns()->get_routine_info(routine_info, decl_routine_info));
16722
        if (OB_FAIL(ret)) {
16723
        } else if (decl_routine_info != nullptr) {
16724
          OX (const_cast<ObPLRoutineInfo*>(decl_routine_info)->set_route_sql(route_sql));
16725
        }
16726
    }
16727
    OX (routine_info->set_route_sql(route_sql));
16728
    OX (routine_info->set_routine_body(routine_body));
16729
    OZ (routine_table.set_routine_ast(idx, routine_ast));
16730
    OX (unit_ast.add_dependency_objects(routine_ast->get_dependency_table()));
16731
    if (OB_SUCC(ret) && unit_ast.get_can_cached()) {
16732
      OX (unit_ast.set_can_cached(routine_ast->get_can_cached()));
16733
    }
16734
    if (OB_SUCC(ret)) {
16735
      if (unit_ast.is_modifies_sql_data()) {
16736
        // do nothing
16737
      } else if (routine_ast->is_modifies_sql_data()) {
16738
        unit_ast.set_modifies_sql_data();
16739
      } else if (unit_ast.is_reads_sql_data()) {
16740
        // do nothing
16741
      } else if (routine_ast->is_reads_sql_data()) {
16742
        unit_ast.set_reads_sql_data();
16743
      } else if (unit_ast.is_contains_sql()) {
16744
        // do nothing
16745
      } else if (routine_ast->is_contains_sql()) {
16746
        unit_ast.set_contains_sql();
16747
      } else if (routine_ast->is_no_sql()) {
16748
        unit_ast.set_no_sql();
16749
      }
16750
      if (routine_ast->is_wps()) {
16751
        unit_ast.set_wps();
16752
      }
16753
      if (routine_ast->is_rps()) {
16754
        unit_ast.set_rps();
16755
      }
16756
      if (routine_ast->is_has_sequence()) {
16757
        unit_ast.set_has_sequence();
16758
      }
16759
      /*if (routine_ast->is_has_out_param()) {
16760
        unit_ast.set_has_out_param();
16761
      }*/
16762
      if (routine_ast->is_external_state()) {
16763
        unit_ast.set_external_state();
16764
      }
16765
    }
16766
    OX (routine_info->set_analyze_flag(routine_ast->get_analyze_flag()));
16767
    // 将routine param中的外部类型加入到当前namespace的type table中。
16768
    for (int64_t i = 0; OB_SUCC(ret) && i < routine_info->get_param_count(); ++i) {
16769
      ObPLRoutineParam *param = routine_info->get_params().at(i);
16770
      CK (OB_NOT_NULL(param));
16771
      if (OB_SUCC(ret) && OB_INVALID_ID != param->get_type().get_user_type_id()) {
16772
        const ObUserDefinedType *user_type = NULL;
16773
        OZ (unit_ast.get_body()->get_namespace().get_pl_data_type_by_id(param->get_type().get_user_type_id(), user_type));
16774
        CK (OB_NOT_NULL(user_type));
16775
        ObSEArray<ObDataType, 8> types;
16776
        OZ (routine_ast->get_body()->get_namespace().expand_data_type(user_type, types));
16777
        OZ (routine_ast->get_body()->get_namespace().get_type_table()->add_external_type(user_type));
16778
      }
16779
    }
16780
    if (OB_FAIL(ret) && OB_NOT_NULL(routine_ast)) {
16781
      routine_ast->~ObPLFunctionAST();
16782
      resolve_ctx_.allocator_.free(routine_ast);
16783
      routine_ast = NULL;
16784
    }
16785
  }
16786
  return ret;
16787
}
16788

16789
int ObPLResolver::resolve_init_routine(const ObStmtNodeTree *parse_tree, ObPLPackageAST &package_ast)
16790
{
16791
  int ret = OB_SUCCESS;
16792
  ObPLRoutineTable &routine_table = package_ast.get_routine_table();
16793
  ObString name("__init__");
16794
  ObString empty_decl_str;
16795
  ObArray<ObPLRoutineParam *> empty_params;
16796
  ObPLRoutineInfo *routine_info = NULL;
16797
  ObPLFunctionAST *routine_ast = NULL;
16798
  if (OB_FAIL(routine_table.make_routine_info(resolve_ctx_.allocator_,
16799
                                                     name,
16800
                                                     PACKAGE_PROCEDURE,
16801
                                                     empty_decl_str,
16802
                                                     package_ast.get_database_id(),
16803
                                                     package_ast.get_id(),
16804
                                                     ObPLRoutineTable::INIT_ROUTINE_IDX,
16805
                                                     ObArray<int64_t>(),
16806
                                                     routine_info))) {
16807
    LOG_WARN("make routine info failed", K(ret));
16808
  } else if (OB_FAIL(routine_table.make_routine_ast(resolve_ctx_.allocator_,
16809
                                                    package_ast.get_db_name(),
16810
                                                    package_ast.get_name(),
16811
                                                    package_ast.get_version(),
16812
                                                    *routine_info,
16813
                                                    routine_ast))) {
16814
    LOG_WARN("make routine ast failed", K(ret));
16815
  } else if (OB_FAIL(resolve_routine_block(parse_tree, *routine_info, *routine_ast))) {
16816
    LOG_WARN("resolve routine block failed", K(ret));
16817
  } else if (OB_FAIL(package_ast.add_dependency_objects(routine_ast->get_dependency_table()))) {
16818
    LOG_WARN("add dependency table failed", K(ret));
16819
  } else {
16820
    routine_ast->get_body()->set_location(
16821
      parse_tree->stmt_loc_.first_line_, parse_tree->stmt_loc_.first_column_);
16822
    routine_table.set_init_routine_info(routine_info);
16823
    routine_table.set_init_routine_ast(routine_ast);
16824
  }
16825
  return ret;
16826
}
16827

16828
int ObPLResolver::resolve_goto(const ObStmtNodeTree *parse_tree,
16829
                               ObPLGotoStmt *stmt,
16830
                               ObPLCompileUnitAST &unit_ast)
16831
{
16832
  UNUSED(unit_ast);
16833
  int ret = OB_SUCCESS;
16834
  if (OB_NOT_NULL(parse_tree)) {
16835
    const ObStmtNodeTree *dst_label = parse_tree->children_[0];
16836
    ObString label;
16837
    if (OB_FAIL(resolve_ident(dst_label, label))) {
16838
      LOG_WARN("failed to resolve ident", K(ret));
16839
    } else {
16840
      stmt->set_dst_label(label);
16841
      current_block_->set_is_contain_goto_stmt(true);
16842
      OX (push_goto_stmts(stmt));
16843
    }
16844
  } else {
16845
    ret = OB_ERR_UNEXPECTED;
16846
    LOG_WARN("goto stmt node is null", K(ret));
16847
  }
16848
  return ret;
16849
}
16850

16851
int ObPLResolver::check_goto(ObPLGotoStmt *stmt)
16852
{
16853
  int ret = OB_SUCCESS;
16854
  int64_t label_idx = OB_INVALID_INDEX;
16855
  bool is_dup_label = false;
16856
  if (OB_ISNULL(stmt)) {
16857
    ret = OB_ERR_UNEXPECTED;
16858
    LOG_WARN("null goto stmt", K(ret));
16859
  } else if (OB_FAIL(resolve_label(stmt->get_dst_label(),
16860
                                   stmt->get_block()->get_namespace(),
16861
                                   label_idx, false))) {
16862
    if (ret == OB_ERR_SP_LILABEL_MISMATCH) {
16863
      const ObPLBlockNS& ns = stmt->get_block()->get_namespace();
16864
      const ObPLLabelTable *label_table = ns.get_label_table();
16865
      const ObString& name = stmt->get_dst_label();
16866
      bool found = false;
16867
      int iret = OB_SUCCESS;
16868
      // search the label in global label table
16869
      for (int64_t i = 0; OB_SUCCESS == iret && i < label_table->get_count(); ++i) {
16870
        const ObString *label_name = label_table->get_label(i);
16871
        if (OB_ISNULL(label_name)) {
16872
          iret = OB_ERR_UNEXPECTED;
16873
          LOG_WARN("label is NULL", K(label_name), K(label_idx), K(ret));
16874
        } else if (0 == name.case_compare(*label_name)) {
16875
          found = true;
16876
          break;
16877
        } else { /*do nothing*/ }
16878
      }
16879
      if (OB_SUCCESS == iret && found) {
16880
        // errno for illeagal goto label
16881
        ret = OB_ERR_GOTO_BRANCH_ILLEGAL;
16882
        LOG_WARN("goto label is illeagal", K(name), K(label_idx), K(ret));
16883
        LOG_USER_ERROR(OB_ERR_GOTO_BRANCH_ILLEGAL, name.length(), name.ptr());
16884
      } else {
16885
        // errno for non-existing label
16886
        ret = OB_ERR_INVALID_GOTO;
16887
        LOG_WARN("Invalid GOTO to non-label", K(name), K(label_idx), K(ret));
16888
        LOG_USER_ERROR(OB_ERR_INVALID_GOTO, name.length(), name.ptr());
16889
      }
16890
    }
16891
  } else if (OB_INVALID_INDEX == label_idx) {
16892
    ret = OB_ERR_UNEXPECTED;
16893
    LOG_WARN("cann't find goto destination label", K(ret));
16894
  } else if (OB_FAIL(stmt->get_block()->get_namespace().check_dup_goto_label(stmt->get_dst_label(), is_dup_label))) {
16895
    LOG_WARN("failed to check goto label dup", K(stmt->get_dst_label()), K(ret));
16896
  } else if (is_dup_label) {
16897
    ret = OB_ERR_DECL_MORE_THAN_ONCE;
16898
    LOG_WARN("label is declared duplicately in this scope", K(stmt->get_dst_label()), K(label_idx), K(ret));
16899
    LOG_USER_ERROR(OB_ERR_DECL_MORE_THAN_ONCE, stmt->get_dst_label().length(), stmt->get_dst_label().ptr());
16900
  } else {
16901
    ObPLLabelTable *pl_label = current_block_->get_namespace().get_label_table();
16902
    if (OB_NOT_NULL(pl_label)) {
16903
      enum GotoRestrictionType restrict_type = RESTRICTION_NO_RESTRICT;
16904
      ObPLStmt *ls = pl_label->get_next_stmt(label_idx);
16905
      if (OB_ISNULL(ls)) {
16906
        ret = OB_ERR_UNEXPECTED;
16907
        LOG_WARN("failed to get destination stmt", K(ret));
16908
      } else if (OB_FAIL(verify_goto_stmt_restriction(*stmt, *ls, restrict_type))) {
16909
        LOG_WARN("failed to verify goto stmt", K(ret));
16910
      } else if (RESTRICTION_NO_RESTRICT != restrict_type) {
16911
        ret = OB_ERR_GOTO_BRANCH_ILLEGAL;
16912
        LOG_WARN("illegal GOTO statement; this GOTO cannot branch to label",
16913
                                                   K(*(pl_label->get_label(label_idx))));
16914
        LOG_USER_ERROR(OB_ERR_GOTO_BRANCH_ILLEGAL, pl_label->get_label(label_idx)->length(),
16915
                                                   pl_label->get_label(label_idx)->ptr());
16916
      } else if (OB_FAIL(check_goto_cursor_stmts(*stmt, *ls))) {
16917
        LOG_WARN("failed to check goto cursor stmts", K(ret));
16918
      } else if (RESTRICTION_NO_RESTRICT == restrict_type) {
16919
        pl_label->set_is_goto_dst(label_idx ,true);
16920
        // 多标签的场景下，在resolve函数中给goto 目的stmt赋值的可能是其它标签，所以这里需要更新一下
16921
        // <<lab1>> <<lab2>> stmt; goto lab2 类似这种，stmt的标签idx指向lab1，所以这里更新为lab2的idx.
16922
        // 但是lab1 和lab2的关联stmt都是一样的，所以能通过lab2找到对应的stmt.
16923
        ls->update_label_index(label_idx);
16924
        stmt->set_dst_stmt(ls);
16925
      } else {
16926
        ret = OB_ERR_UNEXPECTED;
16927
        LOG_WARN("cann't branch to the destination", K(*ls), K(*stmt));
16928
      }
16929
    } else {
16930
      ret = OB_ERR_UNEXPECTED;
16931
      LOG_WARN("labe talbe is not found", K(ret));
16932
    }
16933
  }
16934
  return ret;
16935
}
16936

16937
// 这个函数主要解决goto跳出cursor for loop的时候，需要关闭对应的cursor，这里记录跳出的相关cursor stmts
16938
// 因为这个for loop可以多层嵌套，所以需要记录跳出了多少层。
16939
int ObPLResolver::check_goto_cursor_stmts(ObPLGotoStmt &goto_stmt, const ObPLStmt &dst_stmt)
16940
{
16941
  int ret = OB_SUCCESS;
16942

16943
  const ObPLStmtBlock *goto_block = goto_stmt.get_block();
16944
  const ObPLStmtBlock *dst_block = dst_stmt.get_block();
16945
  const ObPLStmtBlock *parent_blk = NULL;
16946
  if (OB_ISNULL(goto_block) || OB_ISNULL(dst_block)) {
16947
    ret = OB_ERR_UNEXPECTED;
16948
    LOG_WARN("goto or dst block is null", K(ret), K(goto_block), K(dst_block));
16949
  } else if (goto_block == dst_block) {
16950
    // do nothing
16951
  } else {
16952
    // 这里一定是包含关系，dst_block包含了goto_blk，因为前面verify过了。
16953
    parent_blk = goto_block;
16954
    bool exit_flag = false;
16955
    int loopcnt = 0;
16956
    do {
16957
      exit_flag = parent_blk == dst_block;
16958
      const ObIArray<ObPLStmt *> &stmts = parent_blk->get_cursor_stmts();
16959
      bool is_contain = false;
16960
      for (int64_t i = 0; OB_SUCC(ret) && !is_contain && i < stmts.count(); ++i) {
16961
        const ObPLCursorForLoopStmt *cfl_stmt = static_cast<ObPLCursorForLoopStmt *>(stmts.at(i));
16962
        CK (OB_NOT_NULL(cfl_stmt));
16963
        // There is an implicit invariant here:
16964
        // in a multi-level for loop cursor structure, each level has at most 1 cursor that requires closing.
16965
        OZ (check_contain_goto_block(cfl_stmt->get_body(), goto_block, is_contain));
16966
        if (OB_SUCC(ret) && is_contain) {
16967
          OZ (goto_stmt.push_cursor_stmt(cfl_stmt));
16968
        }
16969
      }
16970
      if (OB_SUCC(ret)) {
16971
        parent_blk = parent_blk->get_block();
16972
        loopcnt++;
16973
      }
16974
    } while(OB_SUCC(ret) && OB_NOT_NULL(parent_blk) && !exit_flag);
16975
    // loop invarant
16976
    CK (goto_stmt.get_cursor_stmt_count() <= loopcnt);
16977
  }
16978
  return ret;
16979
}
16980

16981
int ObPLResolver::check_contain_goto_block(const ObPLStmt *cur_stmt,
16982
                                           const ObPLStmtBlock *goto_block,
16983
                                           bool &is_contain)
16984
{
16985
  int ret = OB_SUCCESS;
16986
  is_contain = false;
16987
  CK (OB_NOT_NULL(cur_stmt));
16988
  CK (OB_NOT_NULL(goto_block));
16989
  OX (is_contain = (cur_stmt == goto_block));
16990
  for (int64_t i = 0; OB_SUCC(ret) && !is_contain && i < cur_stmt->get_child_size(); i++) {
16991
    const ObPLStmt *child_stmt = cur_stmt->get_child_stmt(i);
16992
    OZ (SMART_CALL(check_contain_goto_block(child_stmt, goto_block, is_contain)));
16993
  }
16994
  return ret;
16995
}
16996

16997
int ObPLResolver::verify_goto_stmt_restriction(const ObPLStmt &goto_stmt,
16998
                                               const ObPLStmt &dst_stmt,
16999
                                               GotoRestrictionType &result)
17000
{
17001
  int ret = OB_SUCCESS;
17002
  result = RESTRICTION_NO_RESTRICT;
17003
  // A GOTO statement cannot transfer control into an IF statement, CASE statement,
17004
  // LOOP statement, or sub-block.
17005
  // namespace已经做了控制，resolve label的时候，会找不到label
17006

17007
  // A GOTO statement cannot transfer control from one IF statement clause to
17008
  // another, or from one CASE statement WHEN clause to another.
17009
  // namespace已经做了控制，resolve label的时候，会找不到label
17010

17011
  // A GOTO statement cannot transfer control out of a subprogram.
17012
  // namespace已经做了控制，resolve label的时候，会找不到label
17013

17014
  // A GOTO statement cannot transfer control into an exception handler.
17015
  // namespace已经做了控制，resolve label的时候，会找不到label
17016

17017
  // A GOTO statement cannot transfer control from an exception handler back into the
17018
  // current block (but it can transfer control from an exception handler into an
17019
  // enclosing block).
17020
  // for example
17021
  /*
17022
  * case1
17023
  *
17024
  * begin
17025
  *   begin
17026
  *     <<aa>>
17027
  *     some instr
17028
  *   exception
17029
  *     when no_dat_found
17030
  *       goto <<aa>>
17031
  *   end;
17032
  * end;
17033
  *
17034
  * * * *
17035
  * case2
17036
  *
17037
  * begin
17038
  *   begin
17039
  *     <<aa>>
17040
  *     some instr
17041
  *   exception
17042
  *     when no_dat_found
17043
  *       goto <<bb>>
17044
  *   end;
17045
  * <<bb>>
17046
  *   begin
17047
  *     some instr
17048
  *   end;
17049
  * end;
17050
  *
17051
  * * * *
17052
  * case3
17053
  *
17054
  * begin
17055
  * <<cc>>
17056
  *   instr
17057
  *   begin
17058
  *     <<aa>>
17059
  *     some instr
17060
  *   exception
17061
  *     when no_dat_found
17062
  *       goto <<cc>>
17063
  *   end;
17064
  * <<bb>>
17065
  *   begin
17066
  *     some instr
17067
  *   end;
17068
  * end;
17069
  */
17070
  // case1 is illegal, case2, case3 is legal
17071
  const ObPLStmtBlock *blk = goto_stmt.get_block();
17072
  if (OB_ISNULL(blk)) {
17073
    // do nothing
17074
  } else if (blk->in_handler()) {
17075
    if (!blk->is_contain_stmt(&dst_stmt)) {
17076
      // result = RESTRICTION_JUMP_OUT_EXCEPTION;
17077
      bool is_hit = false;
17078
      // tracking back to parent recursively,
17079
      // to see if this goto stmt is transfer control to other encolsing block
17080
      const ObPLStmtBlock *parent = blk->get_block();
17081
      while (OB_NOT_NULL(parent)) {
17082
        if (parent->is_contain_stmt(&dst_stmt) && !parent->in_handler()) {
17083
          is_hit = true;
17084
          break;
17085
        }
17086
        if (parent->get_namespace().explicit_block()) {
17087
          break;
17088
        } else {
17089
          parent = parent->get_block();
17090
        }
17091
      }
17092
      if (is_hit) {
17093
        result = RESTRICTION_JUMP_OUT_EXCEPTION;
17094
      }
17095
    } else {
17096
      // do nothing ...
17097
    }
17098
  } else {
17099
    // do nothing ...
17100
  }
17101
  return ret;
17102
}
17103

17104
int64_t ObPLResolver::combine_line_and_col(const ObStmtLoc &loc)
17105
{
17106
  int64_t bloc = static_cast<int64_t>(loc.first_line_);
17107
  bloc = (bloc<<32) + static_cast<int64_t>(loc.first_column_);
17108
  return bloc;
17109
}
17110

17111
int ObPLResolver::replace_map_or_order_expr(
17112
  uint64_t udt_id, ObRawExpr *&expr, ObPLCompileUnitAST &func)
17113
{
17114
  int ret = OB_SUCCESS;
17115
  ObSEArray<const ObRoutineInfo *, 2> routine_infos;
17116
  const ObRoutineInfo* routine_info = NULL;
17117
  ObRawExpr *left = expr->get_param_expr(0);
17118
  ObRawExpr *right = expr->get_param_expr(1);
17119
  const ObUserDefinedType *user_type = NULL;
17120
  OZ (resolve_ctx_.schema_guard_.get_routine_infos_in_udt(
17121
                  get_tenant_id_by_object_id(udt_id), udt_id, routine_infos));
17122
  OZ (resolve_ctx_.get_user_type(udt_id, user_type));
17123
  CK (OB_NOT_NULL(user_type));
17124
  for (int64_t i = 0; OB_SUCC(ret) && i < routine_infos.count(); ++i) {
17125
    if (routine_infos.at(i)->is_udt_order()) {
17126
      CK (OB_ISNULL(routine_info));
17127
      OX (routine_info = routine_infos.at(i));
17128
    } else if (routine_infos.at(i)->is_udt_map()) {
17129
      CK (OB_ISNULL(routine_info));
17130
      OX (routine_info = routine_infos.at(i));
17131
    }
17132
  }
17133
  if (OB_FAIL(ret)) {
17134
  } else if (OB_NOT_NULL(routine_info)) {
17135
    const ObString &routine_name = routine_info->get_routine_name();
17136
    ObObjAccessIdent left_access_ident(routine_name);
17137
    ObSEArray<ObObjAccessIdx, 1> left_idxs;
17138
    OZ (left_idxs.push_back(ObObjAccessIdx(*user_type,
17139
                                           ObObjAccessIdx::AccessType::IS_EXPR,
17140
                                           ObString(""),
17141
                                           *user_type,
17142
                                           reinterpret_cast<int64_t>(left))));
17143
    OX (left_access_ident.set_pl_udf());
17144
    OX (left_access_ident.access_name_ = routine_name);
17145
    if (routine_info->is_udt_order()) {
17146
      OZ (left_access_ident.params_.push_back(std::make_pair(right, 0)));
17147
    }
17148
    CK (OB_NOT_NULL(current_block_));
17149
    OZ (init_udf_info_of_accessident(left_access_ident));
17150
    OZ (resolve_access_ident(left_access_ident, current_block_->get_namespace(), expr_factory_, &resolve_ctx_.session_info_, left_idxs, func, true));
17151
    CK (left_idxs.at(left_idxs.count() - 1).is_udf_type());
17152
    OX (left = left_idxs.at(left_idxs.count() - 1).get_sysfunc_);
17153
    if (OB_FAIL(ret)) {
17154
    } else if (routine_info->is_udt_order()) {
17155
      ObObjType result_type = left->get_result_type().get_type();
17156
      ObConstRawExpr *const_expr = NULL;
17157
      if (left->get_result_type().get_type() == ObNumberType) {
17158
        number::ObNumber zero;
17159
        OZ (zero.from(static_cast<int64_t>(0), resolve_ctx_.allocator_));
17160
        OZ (ObRawExprUtils::build_const_number_expr(expr_factory_, ObNumberType, zero, const_expr));
17161
      } else {
17162
        OZ (ObRawExprUtils::build_const_int_expr(expr_factory_, left->get_result_type().get_type(), 0, const_expr));
17163
      }
17164
      OX (right = const_expr);
17165
    } else {
17166
      ObObjAccessIdent right_access_ident(routine_name);
17167
      ObSEArray<ObObjAccessIdx, 1> right_idxs;
17168
      OX (right_access_ident.set_pl_udf());
17169
      OX (right_access_ident.access_name_ = routine_name);
17170
      OZ (init_udf_info_of_accessident(right_access_ident));
17171
      OZ (right_idxs.push_back(ObObjAccessIdx(*user_type,
17172
                               ObObjAccessIdx::AccessType::IS_EXPR,
17173
                               ObString(""),
17174
                               *user_type,
17175
                               reinterpret_cast<int64_t>(right))));
17176
      OZ (resolve_access_ident(right_access_ident, current_block_->get_namespace(), expr_factory_, &resolve_ctx_.session_info_, right_idxs, func, true));
17177
      CK (right_idxs.at(right_idxs.count() - 1).is_udf_type());
17178
      OX (right = right_idxs.at(right_idxs.count() - 1).get_sysfunc_);
17179
    }
17180
    CK (OB_NOT_NULL(static_cast<ObOpRawExpr*>(expr)));
17181
    OZ (static_cast<ObOpRawExpr*>(expr)->replace_param_expr(0, left));
17182
    OZ (static_cast<ObOpRawExpr*>(expr)->replace_param_expr(1, right));
17183
    OZ (expr->formalize(&resolve_ctx_.session_info_));
17184
  } else {
17185
    ret = OB_ERR_NO_ORDER_MAP;
17186
    LOG_WARN("A MAP or ORDER function is required for comparing objects in PL/SQL", K(ret));
17187
  }
17188
  return ret;
17189
}
17190

17191

17192
int ObPLResolver::replace_object_compare_expr(ObRawExpr *&expr, ObPLCompileUnitAST &unit_ast)
17193
{
17194
  int ret = OB_SUCCESS;
17195
  CK (OB_NOT_NULL(expr));
17196
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
17197
    OZ (SMART_CALL(replace_object_compare_expr(expr->get_param_expr(i),unit_ast)));
17198
  }
17199
  if (OB_FAIL(ret)) {
17200
  } else if (IS_COMMON_COMPARISON_OP(expr->get_expr_type())) {
17201
    CK (2 == expr->get_param_count());
17202
    CK (OB_NOT_NULL(expr->get_param_expr(0)));
17203
    CK (OB_NOT_NULL(expr->get_param_expr(1)));
17204
    if (OB_FAIL(ret)) {
17205
    } else if (expr->get_param_expr(0)->get_result_type().is_ext()
17206
              && expr->get_param_expr(0)->get_result_type().get_udt_id() != OB_INVALID_ID
17207
              && expr->get_param_expr(1)->get_result_type().is_ext()
17208
              && expr->get_param_expr(1)->get_result_type().get_udt_id() != OB_INVALID_ID) {
17209
      const ObUserDefinedType *l_type = NULL;
17210
      const ObUserDefinedType *r_type = NULL;
17211
      CK (OB_NOT_NULL(current_block_));
17212
      OZ (current_block_->get_namespace().get_user_type(expr->get_param_expr(0)->get_result_type().get_udt_id(), l_type));
17213
      OZ (current_block_->get_namespace().get_user_type(expr->get_param_expr(1)->get_result_type().get_udt_id(), r_type));
17214
      CK (OB_NOT_NULL(l_type));
17215
      CK (OB_NOT_NULL(r_type));
17216
      if (OB_FAIL(ret)) {
17217
      } else if (l_type->get_user_type_id() != r_type->get_user_type_id()) {
17218
        ret = OB_NOT_SUPPORTED;
17219
        LOG_WARN("compare between two different udt type", K(ret), K(l_type), K(r_type));
17220
        LOG_USER_ERROR(OB_NOT_SUPPORTED, "compare between two different composite type");
17221
      } else if (l_type->is_object_type() && r_type->is_object_type()) {
17222
        OZ (replace_map_or_order_expr(l_type->get_user_type_id(), expr, unit_ast));
17223
      }
17224
    }
17225
  }
17226
  return ret;
17227
}
17228

17229
int ObPLResolver::record_error_line(const ObStmtNodeTree *parse_tree,
17230
                                    ObSQLSessionInfo &session_info)
17231
{
17232
  int ret = OB_SUCCESS;
17233
  if (NULL != parse_tree &&
17234
      (0 < parse_tree->stmt_loc_.first_line_ || 0 < parse_tree->stmt_loc_.first_column_)) {
17235
    ret = record_error_line(session_info,
17236
                            parse_tree->stmt_loc_.first_line_,
17237
                            parse_tree->stmt_loc_.first_column_);
17238
  }
17239
  return ret;
17240
}
17241

17242
int ObPLResolver::record_error_line(ObSQLSessionInfo &session_info,
17243
                                    int32_t line,
17244
                                    int32_t col)
17245
{
17246
  int ret = OB_SUCCESS;
17247
  // comp oracle, oracle line is begin with 1 while ob is begin with 0
17248
  line++;
17249
  col++;
17250
  const ObWarningBuffer *buf = common::ob_get_tsi_warning_buffer();
17251
  if (NULL != buf && buf->get_error_line() == 0) {
17252
      ObSqlString &err_msg = session_info.get_pl_exact_err_msg();
17253
      err_msg.reset();
17254
      if (OB_FAIL(err_msg.append_fmt("\nat "))) {
17255
        LOG_WARN("fail to get call stack name.", K(ret));
17256
      } else if (OB_FAIL(err_msg.append_fmt(" line : %d, col : %d", line, col))) {
17257
        LOG_WARN("fail to append line info.", K(ret), K(line), K(col));
17258
      } else {
17259
        LOG_DEBUG("exact error msg: ", K(line), K(col));
17260
      }
17261
      LOG_USER_ERROR_LINE_COLUMN(line, col);
17262
  }
17263
  return ret;
17264
}
17265

17266
int ObPLResolveCtx::get_user_type(uint64_t type_id, const ObUserDefinedType *&user_type, ObIAllocator *allocator) const
17267
{
17268
  int ret = OB_SUCCESS;
17269

17270
  SET_LOG_CHECK_MODE();
17271

17272
  UNUSED(allocator);
17273
  // 首先尝试下是不是UDT Type
17274
  const ObUDTTypeInfo *udt_info = NULL;
17275
  const uint64_t tenant_id = get_tenant_id_by_object_id(type_id);
17276
  OZ (schema_guard_.get_udt_info(tenant_id, type_id, udt_info), type_id);
17277
  if (OB_NOT_NULL(udt_info)) {
17278
    OZ (udt_info->transform_to_pl_type(allocator_, user_type), type_id);
17279
  } else { // 其次尝试下是不是Table Type
17280
    ret = OB_SUCCESS;
17281
    const ObTableSchema* table_schema = NULL;
17282
    const uint64_t tenant_id = session_info_.get_effective_tenant_id();
17283
    OZ (schema_guard_.get_table_schema(tenant_id, type_id, table_schema), type_id);
17284
    if (OB_NOT_NULL(table_schema)) {
17285
      ObRecordType* record_type = NULL;
17286
      OZ (ObPLResolver::build_record_type_by_schema(*this, table_schema, record_type), type_id);
17287
      CK (OB_NOT_NULL(record_type));
17288
      OX (user_type = record_type);
17289
    } else if (type_id != OB_INVALID_ID
17290
              && extract_package_id(type_id) != OB_INVALID_ID) { // 最后尝试下是不是PackageType
17291
      ret = OB_SUCCESS;
17292
      const ObUserDefinedType *package_user_type = NULL;
17293
      if (!common::is_dblink_type_id(type_id)) {
17294
        ObPLPackageManager &package_manager = session_info_.get_pl_engine()->get_package_manager();
17295
        ObPLDataType *copy_pl_type = NULL;
17296
        OZ (package_manager.get_package_type(*this, extract_package_id(type_id), type_id, package_user_type), K(type_id));
17297
        CK (OB_NOT_NULL(user_type = static_cast<const ObUserDefinedType *>(package_user_type)));
17298
      } else {
17299
        OZ (package_guard_.dblink_guard_.get_dblink_type_by_id(extract_package_id(type_id), type_id,
17300
            package_user_type), type_id);
17301
        CK (OB_NOT_NULL(user_type = static_cast<const ObUserDefinedType *>(package_user_type)));
17302
      }
17303
    }
17304
  }
17305

17306
  CANCLE_LOG_CHECK_MODE();
17307

17308
  return ret;
17309
}
17310

17311
int ObPLResolver::check_undeclared_var_type(ObQualifiedName &q_name)
17312
{
17313
  // ret must be OB_ERR_SP_UNDECLARED_VAR before entering this function 
17314
  int ret = OB_SUCCESS;
17315
  const char *empty = "";
17316
  const char *dot = ".";
17317
#define LOG_USER_ERROR_WRONG_SCHEMA_REF_1(name1) \
17318
        ret = OB_ERR_WRONG_SCHEMA_REF; \
17319
        LOG_USER_ERROR(OB_ERR_WRONG_SCHEMA_REF, name1.ptr(), empty, empty, empty, empty)
17320
#define LOG_USER_ERROR_WRONG_SCHEMA_REF_2(name1, name2) \
17321
        ret = OB_ERR_WRONG_SCHEMA_REF; \
17322
        LOG_USER_ERROR(OB_ERR_WRONG_SCHEMA_REF, name1.ptr(), dot, name2.ptr(), empty, empty)
17323
#define LOG_USER_ERROR_WRONG_SCHEMA_REF_3(name1, name2, name3) \
17324
        ret = OB_ERR_WRONG_SCHEMA_REF; \
17325
        LOG_USER_ERROR(OB_ERR_WRONG_SCHEMA_REF, name1.ptr(), dot, name2.ptr(), dot, name3.ptr())
17326
  uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
17327
  uint64_t db_id = resolve_ctx_.session_info_.get_database_id();
17328
  ObSchemaGetterGuard &schema_guard = resolve_ctx_.schema_guard_;
17329
  const ObSimpleTableSchemaV2 *table_schema = NULL;
17330
  ObSchemaType schema_type = OB_MAX_SCHEMA;
17331
  switch (q_name.access_idents_.count()) {
17332
    case 1: {
17333
      ObString name = q_name.access_idents_.at(0).access_name_;
17334
      if (OB_FAIL(check_var_type(name, db_id, schema_type, table_schema, true))) {
17335
        LOG_WARN("failed to check_var_type", K(q_name.access_idents_.at(0).access_name_),
17336
                 K(db_id), K(ret));
17337
      } else if (TABLE_SCHEMA == schema_type || SEQUENCE_SCHEMA == schema_type) {
17338
        LOG_USER_ERROR_WRONG_SCHEMA_REF_1(q_name.access_idents_.at(0).access_name_);
17339
      }
17340
    }
17341
      break;
17342
    case 2: {
17343
      if (OB_FAIL(check_var_type(q_name.access_idents_.at(0).access_name_,
17344
                                 q_name.access_idents_.at(1).access_name_, db_id))) {
17345
        LOG_WARN("failed to check_var_type", K(q_name.access_idents_.at(0).access_name_),
17346
                 K(q_name.access_idents_.at(1).access_name_), K(db_id), K(ret));
17347
        if (OB_ERR_WRONG_SCHEMA_REF == ret) {
17348
          LOG_USER_ERROR_WRONG_SCHEMA_REF_2(q_name.access_idents_.at(0).access_name_,
17349
                                            q_name.access_idents_.at(1).access_name_);
17350
        }
17351
      } else {
17352
        db_id = OB_INVALID_ID;
17353
        if (OB_FAIL(schema_guard.get_database_id(tenant_id, 
17354
                                                q_name.access_idents_.at(0).access_name_, db_id))) {
17355
          LOG_WARN("failed to get_database_id", K(tenant_id),
17356
                   K(q_name.access_idents_.at(0).access_name_), K(ret));
17357
        } else if (OB_INVALID_ID == db_id) {
17358
          // return when not find a db_id
17359
        } else if (OB_FAIL(check_var_type(q_name.access_idents_.at(1).access_name_, db_id,
17360
                                          schema_type, table_schema, true))) {
17361
          LOG_WARN("failed to check_var_type", K(q_name.access_idents_.at(1).access_name_),
17362
                   K(db_id), K(ret));
17363
        } else if (TABLE_SCHEMA == schema_type || SEQUENCE_SCHEMA == schema_type) {
17364
          LOG_USER_ERROR_WRONG_SCHEMA_REF_2(q_name.access_idents_.at(0).access_name_,
17365
                                            q_name.access_idents_.at(1).access_name_);
17366
        }
17367
      }
17368
    }
17369
      break;
17370
    case 3: {
17371
      db_id = OB_INVALID_ID;
17372
      if (OB_FAIL(schema_guard.get_database_id(tenant_id, q_name.access_idents_.at(0).access_name_, 
17373
                                               db_id))) {
17374
        LOG_WARN("failed to get_database_id", K(tenant_id), 
17375
                 K(q_name.access_idents_.at(0).access_name_), K(ret));
17376
      } else if (OB_INVALID_ID == db_id) {
17377
        // return when not find a db_id
17378
      } else if (OB_FAIL(check_var_type(q_name.access_idents_.at(1).access_name_,
17379
                                        q_name.access_idents_.at(2).access_name_,
17380
                                        db_id))) {
17381
        LOG_WARN("failed to check_var_type", K(q_name.access_idents_.at(1).access_name_),
17382
                 K(q_name.access_idents_.at(2).access_name_), K(db_id), K(ret));
17383
        if (OB_ERR_WRONG_SCHEMA_REF == ret) {
17384
          LOG_USER_ERROR_WRONG_SCHEMA_REF_3(q_name.access_idents_.at(0).access_name_,
17385
                                            q_name.access_idents_.at(1).access_name_,
17386
                                            q_name.access_idents_.at(2).access_name_);
17387
        }
17388
      }
17389
    }
17390
      break;
17391
    default: {
17392
      ret = OB_ERR_UNEXPECTED;
17393
      LOG_WARN("the impossible", K(q_name), K(ret));
17394
    }
17395
  }
17396
  if (OB_SUCC(ret)) {
17397
    ret = OB_ERR_SP_UNDECLARED_VAR;
17398
  }
17399
  return ret;
17400
}
17401

17402
int ObPLResolver::check_var_type(ObString &name, uint64_t db_id, ObSchemaType &schema_type,
17403
                                 const ObSimpleTableSchemaV2 *&schema, bool find_synonym)
17404
{
17405
  int ret = OB_SUCCESS;
17406
  uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
17407
  ObSchemaGetterGuard &schema_guard = resolve_ctx_.schema_guard_;
17408
  bool is_exist = false;
17409
  uint64_t seq_id = OB_INVALID_ID;
17410
  bool is_sys_generated = false;
17411
  if (OB_FAIL(schema_guard.get_simple_table_schema(tenant_id, db_id, name, false, schema))) {
17412
    LOG_WARN("failed to get table schema", K(tenant_id), K(db_id), K(name), K(ret));
17413
  } else if (OB_NOT_NULL(schema)) {
17414
    // return when find a table schema
17415
    schema_type = TABLE_SCHEMA;
17416
  } else if (OB_FAIL(schema_guard.check_sequence_exist_with_name(tenant_id, db_id, name,
17417
                                                                 is_exist, seq_id,
17418
                                                                 is_sys_generated))) {
17419
    LOG_WARN("fail to check sequence exist", K(tenant_id), K(db_id), K(name), K(ret));
17420
  } else if (is_exist) {
17421
    // return when find a seq id
17422
    schema_type = SEQUENCE_SCHEMA;
17423
  } else if (find_synonym) {
17424
    ObSchemaChecker schema_checker;
17425
    ObSynonymChecker synonym_checker;
17426
    uint64_t object_db_id = OB_INVALID_ID;
17427
    ObString object_name;
17428
    if (OB_FAIL(schema_checker.init(schema_guard, resolve_ctx_.session_info_.get_sessid()))) {
17429
      LOG_WARN("failed to init schema_checker", K(ret));
17430
    } else if (OB_FAIL(ObResolverUtils::resolve_synonym_object_recursively(
17431
                           schema_checker, synonym_checker, tenant_id,
17432
                           db_id, name, object_db_id, object_name, is_exist))) {
17433
      LOG_WARN("failed to find synonym", K(tenant_id), K(db_id), K(name), K(ret));
17434
    } else if (is_exist) {
17435
      if (OB_FAIL(SMART_CALL(check_var_type(object_name, object_db_id,
17436
                                            schema_type, schema, false)))) {
17437
        LOG_WARN("failed check_var_type", K(object_name), K(object_db_id), K(ret));
17438
      }
17439
    }
17440
  }
17441
  return ret;
17442
}
17443

17444
int ObPLResolver::check_var_type(ObString &name1, ObString &name2, uint64_t db_id) {
17445
  int ret = OB_SUCCESS;
17446
  ObSchemaGetterGuard &schema_guard = resolve_ctx_.schema_guard_;
17447
  const ObSimpleTableSchemaV2 *table_schema = NULL;
17448
  ObSchemaType schema_type = OB_MAX_SCHEMA;
17449
  const ObTableSchema *t_schema = NULL;
17450
  OZ (check_var_type(name1, db_id, schema_type, table_schema, true), name1, db_id);
17451
  if (TABLE_SCHEMA == schema_type) {
17452
    CK (OB_NOT_NULL(table_schema));
17453
    OZ (schema_guard.get_table_schema(table_schema->get_tenant_id(),
17454
                                      table_schema->get_table_id(),
17455
                                      t_schema));
17456
    if (OB_SUCC(ret)) {
17457
      bool has = false;
17458
      CK (OB_NOT_NULL(t_schema));
17459
      OZ (t_schema->has_column(name2, has));
17460
      if (OB_SUCC(ret)) {
17461
        if (has) {
17462
          ret = OB_ERR_WRONG_SCHEMA_REF;
17463
          LOG_WARN("Table,View Or Sequence reference not allowed in this context", K(ret));
17464
        } else {
17465
          ret = OB_ERR_COMPONENT_UNDECLARED;
17466
          LOG_WARN("component must be declared", K(ret));
17467
          LOG_USER_ERROR(OB_ERR_COMPONENT_UNDECLARED, name2.length(), name2.ptr());
17468
        }
17469
      }
17470
    }
17471
  } else if (SEQUENCE_SCHEMA == schema_type) {
17472
    ret = OB_ERR_COMPONENT_UNDECLARED;
17473
    LOG_WARN("component must be declared", K(ret));
17474
    LOG_USER_ERROR(OB_ERR_COMPONENT_UNDECLARED, name2.length(), name2.ptr());
17475
  }
17476
  return ret;
17477
}
17478

17479
int ObPLResolver::check_update_column(const ObPLBlockNS &ns, const ObIArray<ObObjAccessIdx>& access_idxs)
17480
{
17481
  int ret = OB_SUCCESS;
17482
  if (resolve_ctx_.session_info_.is_for_trigger_package()
17483
      && 2 == access_idxs.count()
17484
      && 0 != access_idxs.at(1).var_name_.case_compare(OB_HIDDEN_LOGICAL_ROWID_COLUMN_NAME)
17485
      && access_idxs.at(0).var_name_.prefix_match(":")
17486
      && lib::is_oracle_mode()) {
17487
    ObSchemaChecker schema_checker;
17488
    const ObTriggerInfo *trg_info = NULL;
17489
    const uint64_t tenant_id = resolve_ctx_.session_info_.get_effective_tenant_id();
17490
    OZ (schema_checker.init(resolve_ctx_.schema_guard_, resolve_ctx_.session_info_.get_sessid()));
17491
    OZ (schema_checker.get_trigger_info(tenant_id,
17492
                                        ns.get_db_name(),
17493
                                        ns.get_package_name(),
17494
                                        trg_info));
17495
    CK (OB_NOT_NULL(trg_info));
17496
    if (OB_SUCC(ret)) {
17497
      ObString var_name = access_idxs.at(0).var_name_;
17498
      ++var_name;
17499
      if (0 == trg_info->get_ref_new_name().case_compare(var_name)
17500
          || 0 == trg_info->get_ref_old_name().case_compare(var_name)) {
17501
        const uint64_t table_id = trg_info->get_base_object_id();
17502
        const ObString column_name = access_idxs.at(1).var_name_;
17503
        const ObTableSchema *table_schema = NULL;
17504
        const ObColumnSchemaV2 *col_schema = NULL;
17505
        OZ (resolve_ctx_.schema_guard_.get_table_schema(tenant_id, table_id, table_schema));
17506
        CK (OB_NOT_NULL(table_schema));
17507
        OX (col_schema = table_schema->get_column_schema(column_name));
17508
        CK (OB_NOT_NULL(col_schema));
17509
        if (OB_SUCC(ret)) {
17510
          if (col_schema->is_generated_column()) {
17511
            ret = OB_ERR_CANNOT_UPDATE_VIRTUAL_COL_IN_TRG;
17512
            LOG_WARN("virtual column cannot be updated in trigger body", K(col_schema->get_column_name_str()), K(ret));
17513
          }
17514
        }
17515
      }
17516
    }
17517
  }
17518
  return ret;
17519
}
17520

17521
int ObPLResolver::resolve_do(const ObStmtNodeTree *parse_tree, ObPLDoStmt *stmt,
17522
                             ObPLFunctionAST &func)
17523
{
17524
  int ret = OB_SUCCESS;
17525
  if (OB_ISNULL(parse_tree) || OB_ISNULL(stmt) || OB_ISNULL(current_block_)) {
17526
    ret = OB_ERR_UNEXPECTED;
17527
    LOG_WARN("parse_tree is NULL", K(parse_tree), K(stmt), K(current_block_), K(ret));
17528
  } else if (OB_ISNULL(parse_tree->children_[0])) {
17529
    ret = OB_ERR_UNEXPECTED;
17530
    LOG_WARN("invalid do stmt", K(parse_tree->children_[0]), K(ret));
17531
  } else if (T_EXPR_LIST != parse_tree->children_[0]->type_) {
17532
    ret = OB_ERR_UNEXPECTED;
17533
    LOG_WARN("invalid do stmt", K(parse_tree->children_[0]->type_), K(ret));
17534
  } else {
17535
    const ObStmtNodeTree *current_node = parse_tree->children_[0];
17536
    for (int64_t i = 0; OB_SUCC(ret) && i < current_node->num_child_; ++i) {
17537
      ObRawExpr *value_expr = NULL;
17538
      const ObStmtNodeTree *value_node = current_node->children_[i];
17539
      if (OB_ISNULL(value_node)) {
17540
        ret = OB_ERR_UNEXPECTED;
17541
        LOG_WARN("expr node is NULL", K(value_node), K(ret));
17542
      } else if (OB_FAIL(resolve_expr(value_node, func, value_expr,
17543
                        combine_line_and_col(value_node->stmt_loc_),
17544
                        true, NULL))) {
17545
          LOG_WARN("failed to resolve expr ", K(value_node), K(ret));
17546
      } else if (OB_FAIL(stmt->add_value(func.get_expr_count() - 1))) {
17547
        LOG_WARN("failed to add_value ", K(stmt), K(ret));
17548
      }
17549
    }
17550
  }
17551
  
17552
  return ret;
17553
}
17554

17555
int ObPLResolver::get_udt_names(
17556
  ObSchemaGetterGuard &schema_guard, const uint64_t udt_id, ObString &database_name, ObString &udt_name)
17557
{
17558
  int ret = OB_SUCCESS;
17559
  if (OB_INVALID_ID != udt_id) {
17560
    uint64_t db_id = OB_INVALID_ID;
17561
    const ObUDTTypeInfo *udt_info = NULL;
17562
    const ObSimpleDatabaseSchema *db_schema = NULL;
17563
    const uint64_t tenant_id = get_tenant_id_by_object_id(udt_id);
17564
    OZ (schema_guard.get_udt_info(tenant_id, udt_id, udt_info));
17565
    CK (OB_NOT_NULL(udt_info));
17566
    OX (db_id = udt_info->get_database_id());
17567
    CK (OB_INVALID_ID != db_id);
17568
    OZ (schema_guard.get_database_schema(tenant_id, db_id, db_schema));
17569
    CK (OB_NOT_NULL(db_schema));
17570
    if (OB_SUCC(ret) && resolve_ctx_.session_info_.get_database_name().case_compare(db_schema->get_database_name_str()) != 0) {
17571
      OX (database_name = db_schema->get_database_name_str());
17572
    }
17573
    OX (udt_name = udt_info->get_type_name());
17574
  }
17575
  return ret;
17576
}
17577

17578
int ObPLResolver::get_udt_database_name(ObSchemaGetterGuard &schema_guard, const uint64_t udt_id, ObString &db_name)
17579
{
17580
  int ret = OB_SUCCESS;
17581
  if (OB_INVALID_ID != udt_id) {
17582
    uint64_t db_id = OB_INVALID_ID;
17583
    const ObUDTTypeInfo *udt_info = NULL;
17584
    const ObSimpleDatabaseSchema *db_schema = NULL;
17585
    const uint64_t tenant_id = get_tenant_id_by_object_id(udt_id);
17586
    OZ (schema_guard.get_udt_info(tenant_id, udt_id, udt_info));
17587
    CK (OB_NOT_NULL(udt_info));
17588
    OX (db_id = udt_info->get_database_id());
17589
    CK (OB_INVALID_ID != db_id);
17590
    OZ (schema_guard.get_database_schema(tenant_id, db_id, db_schema));
17591
    CK (OB_NOT_NULL(db_schema));
17592
    OX (db_name = db_schema->get_database_name_str());
17593
  }
17594
  return ret;
17595
}
17596

17597
bool ObPLResolver::check_with_rowid(const ObString &routine_name, bool is_for_trigger)
17598
{
17599
  bool with_rowid = false;
17600
  if (is_for_trigger && lib::is_oracle_mode()) {
17601
    if (0 == routine_name.case_compare("calc_when") ||
17602
        0 == routine_name.case_compare("before_row") ||
17603
        0 == routine_name.case_compare("after_row")) {
17604
      with_rowid = true;
17605
    }
17606
  }
17607
  return with_rowid;
17608
}
17609

17610
int ObPLResolver::recursive_replace_expr(ObRawExpr *expr,
17611
                                         ObQualifiedName &qualified_name,
17612
                                         ObRawExpr *real_expr)
17613
{
17614
  int ret = OB_SUCCESS;
17615
  CK (OB_NOT_NULL(expr));
17616
  CK (OB_NOT_NULL(real_expr));
17617
  for (int64_t i = 0; OB_SUCC(ret) && i < expr->get_param_count(); ++i) {
17618
    CK (OB_NOT_NULL(expr->get_param_expr(i)));
17619
    if (OB_FAIL(ret)) {
17620
    } else if (expr->get_param_expr(i) == qualified_name.ref_expr_) {
17621
      expr->get_param_expr(i) = real_expr;
17622
    } else if (expr->get_param_expr(i)->get_param_count() > 0) {
17623
      OZ (recursive_replace_expr(expr->get_param_expr(i), qualified_name, real_expr));
17624
    }
17625
  }
17626
  return ret;
17627
}
17628

17629
ObPLSwitchDatabaseGuard::ObPLSwitchDatabaseGuard(sql::ObSQLSessionInfo &session_info,
17630
                                                 share::schema::ObSchemaGetterGuard &schema_guard,
17631
                                                 ObPLCompileUnitAST &func,
17632
                                                 int &ret_val,
17633
                                                 bool with_rowid)
17634
  : ret_(ret_val),
17635
    session_info_(session_info),
17636
    database_id_(OB_INVALID_ID),
17637
    need_reset_(false)
17638
{
17639
  int ret = OB_SUCCESS;
17640
  const share::schema::ObDatabaseSchema *db_schema = NULL;
17641
  if (func.is_package() && with_rowid) {
17642
    ObPLPackageAST &pkg_ast = static_cast<ObPLPackageAST &>(func);
17643
    if (ObTriggerInfo::is_trigger_package_id(pkg_ast.get_id())
17644
        || ObTriggerInfo::is_trigger_body_package_id(pkg_ast.get_id())) {
17645
      uint64_t tenant_id = session_info_.get_effective_tenant_id();
17646
      uint64_t trg_id = ObTriggerInfo::get_package_trigger_id(pkg_ast.get_id());
17647
      const ObTriggerInfo *trg_info = NULL;
17648
      const ObTableSchema *table_schema = NULL;
17649
      OZ (schema_guard.get_trigger_info(tenant_id, trg_id, trg_info));
17650
      OV (OB_NOT_NULL(trg_info), OB_ERR_UNEXPECTED, K(trg_id));
17651
      OZ (schema_guard.get_table_schema(tenant_id, trg_info->get_base_object_id(), table_schema));
17652
      OV (OB_NOT_NULL(table_schema), OB_ERR_UNEXPECTED, KPC(trg_info));
17653
      OX (database_id_ = table_schema->get_database_id());
17654
    }
17655
  }
17656
  if (OB_SUCC(ret)
17657
      && session_info_.get_database_id() != database_id_
17658
      && OB_INVALID_ID != database_id_) {
17659
    OZ (schema_guard.get_database_schema(session_info_.get_effective_tenant_id(),
17660
                                         database_id_,
17661
                                         db_schema));
17662
    OV (OB_NOT_NULL(db_schema), OB_ERR_UNEXPECTED, K(database_id_));
17663
    OX (database_id_ = session_info_.get_database_id());
17664
    OZ (database_name_.append(session_info_.get_database_name()));
17665
    OZ (session_info_.set_default_database(db_schema->get_database_name_str()));
17666
    OX (session_info_.set_database_id(db_schema->get_database_id()));
17667
    OX (need_reset_ = true);
17668
  }
17669
  ret_ = ret;
17670
}
17671

17672
ObPLSwitchDatabaseGuard::~ObPLSwitchDatabaseGuard()
17673
{
17674
  int ret = OB_SUCCESS;
17675
  if (need_reset_) {
17676
    if (OB_FAIL(session_info_.set_default_database(database_name_.string()))) {
17677
      LOG_ERROR("failed to reset default database", K(ret), K(database_name_.string()));
17678
    } else {
17679
      session_info_.set_database_id(database_id_);
17680
    }
17681
  }
17682
  if (OB_SUCCESS == ret_) {
17683
    ret_ = ret;
17684
  }
17685
}
17686

17687
}
17688
}
17689

17690