/**

* Copyright (c) 2021 OceanBase

* OceanBase CE is licensed under Mulan PubL v2.

* You can use this software according to the terms and conditions of the Mulan PubL v2.

* You may obtain a copy of Mulan PubL v2 at:

* http://license.coscl.org.cn/MulanPubL-2.0

* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,

* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,

* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.

* See the Mulan PubL v2 for more details.

*/

#define USING_LOG_PREFIX SQL_RESV

#include "sql/resolver/ob_resolver_utils.h"

#include "lib/charset/ob_charset.h"

#include "lib/timezone/ob_time_convert.h"

#include "share/schema/ob_column_schema.h"

#include "share/object/ob_obj_cast.h"

#include "share/ob_get_compat_mode.h"

#include "common/sql_mode/ob_sql_mode_utils.h"

#include "common/object/ob_obj_type.h"

#include "sql/parser/parse_malloc.h"

#include "sql/parser/parse_node.h"

#include "sql/parser/ob_parser.h"

#include "sql/resolver/ob_column_ref.h"

#include "sql/resolver/dml/ob_select_stmt.h"

#include "sql/resolver/expr/ob_raw_expr_resolver_impl.h"

#include "sql/resolver/expr/ob_raw_expr_util.h"

#include "sql/resolver/expr/ob_raw_expr_part_func_checker.h"

#include "sql/resolver/expr/ob_raw_expr_part_expr_checker.h"

#include "sql/resolver/expr/ob_raw_expr_printer.h"

#include "sql/resolver/ddl/ob_ddl_resolver.h"

#include "sql/ob_sql_utils.h"

#include "pl/ob_pl_resolver.h"

#include "pl/ob_pl_package.h"

#include "pl/ob_pl_stmt.h"

#include "observer/ob_server_struct.h"

#include "sql/rewrite/ob_transform_utils.h"

#include "sql/engine/expr/ob_expr_column_conv.h"

#include "sql/engine/expr/ob_datum_cast.h"

#include "sql/parser/ob_parser_utils.h"

#include "lib/json/ob_json_print_utils.h"

#include "sql/engine/expr/ob_expr_unistr.h"

namespace oceanbase

{

using namespace common;

using namespace share::schema;

using namespace obrpc;

using namespace pl;

namespace sql

{

ObItemType ObResolverUtils::item_type_ = T_INVALID;

const ObString ObResolverUtils::stmt_type_string[] = {

#define OB_STMT_TYPE_DEF(stmt_type, priv_check_func, id, action_type) ObString::make_string(#stmt_type),

#include "sql/resolver/ob_stmt_type.h"

#undef OB_STMT_TYPE_DEF

};

int ObResolverUtils::get_user_type(ObIAllocator *allocator,

ObSQLSessionInfo *session_info,

ObMySQLProxy *sql_proxy,

share::schema::ObSchemaGetterGuard *schema_guard,

pl::ObPLPackageGuard &package_guard,

uint64_t type_id,

const pl::ObUserDefinedType *&user_type)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(allocator));

CK (OB_NOT_NULL(session_info));

CK (OB_NOT_NULL(sql_proxy));

CK (OB_NOT_NULL(schema_guard));

OX (user_type = NULL);

if (OB_SUCC(ret)) {

pl::ObPLResolveCtx resolve_ctx(

*allocator, *session_info, *schema_guard, package_guard, *sql_proxy, false);

if (!package_guard.is_inited()) {

OZ (package_guard.init());

}

OZ (resolve_ctx.get_user_type(type_id, user_type, allocator));

}

return ret;

}

int ObResolverUtils::get_all_function_table_column_names(const TableItem &table_item,

ObResolverParams &params,

ObIArray<ObString> &column_names)

{

int ret = OB_SUCCESS;

ObRawExpr *table_expr = NULL;

ObPLPackageGuard package_guard(params.session_info_->get_effective_tenant_id());

const ObUserDefinedType *user_type = NULL;

CK (OB_LIKELY(table_item.is_function_table()));

CK (OB_NOT_NULL(table_expr = table_item.function_table_expr_));

CK (table_expr->get_udt_id() != OB_INVALID_ID);

CK (OB_NOT_NULL(params.schema_checker_));

OZ (ObResolverUtils::get_user_type(

params.allocator_, params.session_info_, params.sql_proxy_,

params.schema_checker_->get_schema_guard(),

package_guard,

table_expr->get_udt_id(), user_type));

CK (OB_NOT_NULL(user_type));

if (OB_SUCC(ret) && !user_type->is_collection_type()) {

ret = OB_NOT_SUPPORTED;

LOG_WARN("function table get udf with return type not table type",

K(ret), K(user_type->is_collection_type()));

LOG_USER_ERROR(OB_NOT_SUPPORTED, "user define type is not collation type in function table");

}

const ObCollectionType *coll_type = NULL;

CK (OB_NOT_NULL(coll_type = static_cast<const ObCollectionType*>(user_type)));

if (OB_SUCC(ret)

&& !coll_type->get_element_type().is_obj_type()

&& !coll_type->get_element_type().is_record_type()) {

ret = OB_NOT_SUPPORTED;

LOG_WARN("not suppoert type in table function", K(ret), KPC(coll_type));

ObString err;

err.write(coll_type->get_name().ptr(), coll_type->get_name().length());

err.write(" collation type in table function\0", sizeof(" collation type in table function\0"));

LOG_USER_ERROR(OB_NOT_SUPPORTED, err.ptr());

}

if (OB_SUCC(ret) && coll_type->get_element_type().is_obj_type()) {

OZ (column_names.push_back(ObString("COLUMN_VALUE")));

}

if (OB_SUCC(ret) && coll_type->get_element_type().is_record_type()) {

const ObRecordType *record_type = NULL;

const ObUserDefinedType *user_type = NULL;

CK (OB_NOT_NULL(params.schema_checker_));

OZ (ObResolverUtils::get_user_type(

params.allocator_, params.session_info_, params.sql_proxy_,

params.schema_checker_->get_schema_guard(),

package_guard,

coll_type->get_element_type().get_user_type_id(), user_type));

CK (OB_NOT_NULL(user_type));

CK (user_type->is_record_type());

CK (OB_NOT_NULL(record_type = static_cast<const ObRecordType *>(user_type)));

for (int64_t i = 0; OB_SUCC(ret) && i < record_type->get_member_count(); ++i) {

const ObString *member_name = record_type->get_record_member_name(i);

CK (OB_NOT_NULL(member_name));

OZ (column_names.push_back(*member_name));

}

}

return ret;

}

int ObResolverUtils::check_function_table_column_exist(const TableItem &table_item,

ObResolverParams &params,

const ObString &column_name)

{

int ret = OB_SUCCESS;

ObSEArray<ObString, 16> column_names;

bool exist = false;

OZ (get_all_function_table_column_names(table_item, params, column_names));

for (int64_t i = 0; OB_SUCC(ret) && i < column_names.count(); ++i) {

if (ObCharset::case_compat_mode_equal(column_names.at(i), column_name)) {

exist = true;

break;

}

}

if (!exist) {

ret = OB_ERR_BAD_FIELD_ERROR;

LOG_WARN("not found column in table function", K(ret), K(column_name));

}

return ret;

}

int ObResolverUtils::check_json_table_column_exists(const TableItem &table_item,

ObResolverParams &params,

const ObString &column_name,

bool& exists)

{

int ret = OB_SUCCESS;

ObSEArray<ObString, 16> column_names;

bool exist = false;

CK(table_item.is_json_table());

CK (OB_NOT_NULL(table_item.json_table_def_));

ObJsonTableDef* jt_def = table_item.json_table_def_;

for (size_t i = 0; OB_SUCC(ret) && i < jt_def->all_cols_.count(); ++i) {

ObJtColBaseInfo* col_info = jt_def->all_cols_.at(i);

if (col_info->col_type_ != NESTED_COL_TYPE) {

ObString& cur_column_name = col_info->col_name_;

if (ObCharset::case_compat_mode_equal(cur_column_name, column_name)) {

exists = true;

break;

}

}

}

if (OB_SUCC(ret) && !exists) {

ret = OB_ERR_BAD_FIELD_ERROR;

LOG_WARN("not found column in table function", K(ret), K(column_name));

}

return ret;

}

int ObResolverUtils::resolve_extended_type_info(const ParseNode &str_list_node, ObIArray<ObString>& type_info_array)

{

int ret = OB_SUCCESS;

ObString cur_type_info;

CK(str_list_node.num_child_ > 0);

for (int64_t i = 0; OB_SUCC(ret) && i < str_list_node.num_child_; ++i) {

cur_type_info.reset();

const ParseNode *str_node = str_list_node.children_[i];

if (OB_ISNULL(str_node)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("invalid str_node", K(ret), K(str_node), K(i));

} else if (FALSE_IT(cur_type_info.assign_ptr(str_node->str_value_, static_cast<ObString::obstr_size_t>(str_node->str_len_)))) {

} else if (OB_FAIL(type_info_array.push_back(cur_type_info))) {

LOG_WARN("fail to push back type info", K(ret), K(i), K(cur_type_info));

}

}

return ret;

}

int ObResolverUtils::check_extended_type_info(common::ObIAllocator &alloc,

ObIArray<ObString> &type_infos,

ObCollationType ori_cs_type,

const ObString &col_name,

ObObjType col_type,

ObCollationType cs_type,

ObSQLMode sql_mode)

{

int ret = OB_SUCCESS;

ObString cur_type_info;

const ObString &sep = ObCharsetUtils::get_const_str(cs_type, ',');

int32_t dup_cnt;

// convert type infos from %ori_cs_type to %cs_type first

FOREACH_CNT_X(str, type_infos, OB_SUCC(ret)) {

OZ(ObCharset::charset_convert(alloc, *str, ori_cs_type, cs_type, *str));

}

if (OB_SUCC(ret)) {

}

for (int64_t i = 0; OB_SUCC(ret) && i < type_infos.count(); ++i) {

ObString &cur_val = type_infos.at(i);

int32_t no_sp_len = static_cast<int32_t>(ObCharset::strlen_byte_no_sp(cs_type, cur_val.ptr(), cur_val.length()));

cur_val.assign_ptr(cur_val.ptr(), static_cast<ObString::obstr_size_t>(no_sp_len)); //remove tail space

int32_t char_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, cur_val.ptr(), cur_val.length()));

if (OB_UNLIKELY(char_len > OB_MAX_INTERVAL_VALUE_LENGTH)) { //max value length

ret = OB_ER_TOO_LONG_SET_ENUM_VALUE;

LOG_USER_ERROR(OB_ER_TOO_LONG_SET_ENUM_VALUE, col_name.length(), col_name.ptr());

} else if (ObSetType == col_type //set can't contain commas

&& 0 != ObCharset::instr(cs_type, cur_val.ptr(), cur_val.length(),

sep.ptr(), sep.length())) {

ret = OB_ERR_ILLEGAL_VALUE_FOR_TYPE;

LOG_USER_ERROR(OB_ERR_ILLEGAL_VALUE_FOR_TYPE, "set", cur_val.length(), cur_val.ptr());

} else {/*do nothing*/}

}

if (OB_FAIL(ret)) {

} else if (OB_FAIL(check_duplicates_in_type_infos(//check duplicate value

type_infos, col_name, col_type, cs_type, sql_mode, dup_cnt))) {

LOG_WARN("fail to check duplicate", K(ret), K(dup_cnt), K(type_infos), K(col_name), K(col_type));

} else if (OB_FAIL(check_max_val_count(//check value count

col_type, col_name, type_infos.count(), dup_cnt))) {

LOG_WARN("fail to check max val count", K(ret), K(col_type), K(col_name), K(type_infos), K(dup_cnt));

} else {/*do nothing*/}

return ret;

}

int ObResolverUtils::check_duplicates_in_type_infos(const ObIArray<common::ObString> &type_infos,

const ObString &col_name,

ObObjType col_type,

ObCollationType cs_type,

ObSQLMode sql_mode,

int32_t &dup_cnt)

{

int ret = OB_SUCCESS;

dup_cnt = 0;

for (uint32_t i = 0; OB_SUCC(ret) && i < type_infos.count() - 1; ++i) {

int32_t pos = i + 1;

const ObString &cur_val = type_infos.at(i);

if (OB_FAIL(find_type(type_infos, cs_type, cur_val, pos))) {

LOG_WARN("fail to find type", K(type_infos), K(cur_val), K(pos));

} else if (OB_UNLIKELY(pos >= 0)) {

++dup_cnt;

if (is_strict_mode(sql_mode)) {

ret = OB_ER_DUPLICATED_VALUE_IN_TYPE;

LOG_USER_ERROR(OB_ER_DUPLICATED_VALUE_IN_TYPE, col_name.length(), col_name.ptr(),

cur_val.length(), cur_val.ptr(), ob_sql_type_str(col_type));

} else {

LOG_USER_WARN(OB_ER_DUPLICATED_VALUE_IN_TYPE, col_name.length(), col_name.ptr(),

cur_val.length(), cur_val.ptr(), ob_sql_type_str(col_type));

}

}

}

return ret;

}

int ObResolverUtils::check_max_val_count(ObObjType type, const ObString &col_name, int64_t val_cnt, int32_t dup_cnt)

{

int ret = OB_SUCCESS;

if (ObEnumType == type) {

if (val_cnt > OB_MAX_ENUM_ELEMENT_NUM) {

ret = OB_ER_TOO_BIG_ENUM;

LOG_USER_ERROR(OB_ER_TOO_BIG_ENUM, col_name.length(), col_name.ptr());

}

} else if (ObSetType == type) {

if (val_cnt - dup_cnt > OB_MAX_SET_ELEMENT_NUM) {

ret = OB_ERR_TOO_BIG_SET;

LOG_USER_ERROR(OB_ERR_TOO_BIG_SET, col_name.length(), col_name.ptr());

}

} else {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("unexpected type", K(ret), K(val_cnt), K(dup_cnt));

}

return ret;

}

int ObResolverUtils::check_routine_exists(const ObSQLSessionInfo *session_info,

ObSchemaChecker *schema_checker,

pl::ObPLBlockNS *secondary_namespace,

const ObString &db_name,

const ObString &package_name,

const ObString &routine_name,

const share::schema::ObRoutineType routine_type,

bool &exists,

pl::ObProcType &proc_type,

uint64_t udt_id)

{

int ret = OB_SUCCESS;

exists = false;

proc_type = pl::INVALID_PROC_TYPE;

if (NULL != secondary_namespace) {

if (OB_FAIL(secondary_namespace->check_routine_exists(db_name, package_name, routine_name,

routine_type, exists, proc_type, udt_id))) {

LOG_WARN("failed to check routine exists",

K(ret), K(db_name), K(package_name),

K(routine_name), K(udt_id), K(routine_type), K(exists), K(proc_type));

}

}

if (OB_SUCC(ret) && !exists) {

if (NULL == session_info || NULL == schema_checker) {

//PL resovler don't have session info and schema checker

} else {

if (OB_FAIL(check_routine_exists(*schema_checker,

*session_info,

db_name,

package_name,

routine_name,

routine_type,

exists,

udt_id))) {

LOG_WARN("failed to check_routine_exists",

K(ret), K(db_name), K(package_name),

K(routine_name), K(udt_id), K(routine_type), K(exists), K(proc_type));

} else if (exists) {

proc_type = ROUTINE_PROCEDURE_TYPE == routine_type ? pl::STANDALONE_PROCEDURE : pl::STANDALONE_FUNCTION;

} else { /*do nothing*/ }

}

}

return ret;

}

int ObResolverUtils::check_routine_exists(ObSchemaChecker &schema_checker,

const ObSQLSessionInfo &session_info,

const ObString &db_name,

const ObString &package_name,

const ObString &routine_name,

const share::schema::ObRoutineType routine_type,

bool &exists,

uint64_t udt_id)

{

int ret = OB_SUCCESS;

exists = false;

common::ObArray<const share::schema::ObIRoutineInfo *> routines;

if (OB_FAIL(get_candidate_routines(schema_checker,

session_info.get_effective_tenant_id(),

session_info.get_database_name(),

db_name,

package_name,

routine_name,

routine_type,

routines,

udt_id))) {

LOG_WARN("failed to get candidate routines",

K(ret),

K(db_name), K(package_name), K(routine_name), K(udt_id), K(routine_type), K(exists));

} else {

exists = !routines.empty();

}

return ret;

}

int ObResolverUtils::get_candidate_routines(ObSchemaChecker &schema_checker,

uint64_t tenant_id, const ObString &current_database, const ObString &db_name,

const ObString &package_name, const ObString &routine_name,

const share::schema::ObRoutineType routine_type,

common::ObIArray<const share::schema::ObIRoutineInfo *> &routines,

uint64_t udt_id, const pl::ObPLResolveCtx *resolve_ctx)

{

int ret = OB_SUCCESS;

uint64_t package_id = OB_INVALID_ID;

uint64_t database_id = OB_INVALID_ID;

uint64_t object_db_id = OB_INVALID_ID;

ObString object_name;

ObString real_db_name;

int64_t compatible_mode = COMPATIBLE_MYSQL_MODE;

if (OB_SYS_TENANT_ID != tenant_id) {

lib::Worker::CompatMode compat_mode = lib::Worker::CompatMode::MYSQL;

if (OB_FAIL(share::ObCompatModeGetter::get_tenant_mode(tenant_id, compat_mode))) {

LOG_WARN("fail to get tenant mode", K(tenant_id), K(compat_mode), K(ret));

} else {

compatible_mode = (lib::Worker::CompatMode::ORACLE == compat_mode) ?

COMPATIBLE_ORACLE_MODE : COMPATIBLE_MYSQL_MODE;

}

} else {

compatible_mode = lib::is_oracle_mode() ? COMPATIBLE_ORACLE_MODE

: COMPATIBLE_MYSQL_MODE;

}

UNUSED(udt_id);

OV (!routine_name.empty(), OB_INVALID_ARGUMENT, K(routine_name));

OV (OB_LIKELY(ROUTINE_PROCEDURE_TYPE == routine_type || ROUTINE_FUNCTION_TYPE == routine_type),

OB_INVALID_ARGUMENT, K(routine_type));

if (OB_SUCC(ret)) { // adjust database name for empty.

real_db_name = db_name;

if (db_name.empty()) {

real_db_name = current_database;

if (real_db_name.empty()) {

ret = OB_ERR_NO_DB_SELECTED;

LOG_WARN("no db select",

K(routine_type), K(db_name), K(package_name), K(routine_name), K(ret));

}

}

}

#define TRY_SYNONYM(synonym_name) \

if ((OB_FAIL(ret) || 0 == routines.count()) \

&& OB_ALLOCATE_MEMORY_FAILED != ret) { \

ret = OB_SUCCESS; \

bool exist = false; \

ObSynonymChecker synonym_checker; \

OZ (resolve_synonym_object_recursively( \

schema_checker, synonym_checker, \

tenant_id, database_id, synonym_name, \

object_db_id, object_name, exist)); \

if (OB_SUCC(ret) && exist) { \

need_try_synonym = true; \

} \

}

#define GET_STANDALONE_ROUTINE() \

if (OB_FAIL(ret)) { \

} else if (ROUTINE_PROCEDURE_TYPE == routine_type) { \

if (OB_FAIL(schema_checker.get_standalone_procedure_info( \

tenant_id, object_db_id, object_name, routine_info))) { \

LOG_WARN("failed to get procedure info", \

K(ret), K(tenant_id), K(real_db_name), K(routine_name), K(object_name), K(ret)); \

} else { \

LOG_DEBUG("success get procedure info", \

K(ret), K(tenant_id), K(real_db_name), K(routine_name), K(object_name), K(ret)); \

} \

} else { \

if (OB_FAIL(schema_checker.get_standalone_function_info( \

tenant_id, object_db_id, object_name, routine_info))) { \

LOG_WARN("failed to get function info", \

K(ret), K(tenant_id), K(real_db_name), K(package_name), K(routine_name), \

K(object_db_id), K(db_name), K(object_name), K(ret)); \

} \

} \

if (OB_SUCC(ret) && NULL != routine_info) { \

OZ (routines.push_back(routine_info)); \

}

if (OB_FAIL(ret)) {

// do nothing ...

} else if (package_name.empty()) { // must be standalone procedure/function.

const share::schema::ObRoutineInfo *routine_info = NULL;

bool need_try_synonym = false;

OZ (schema_checker.get_database_id(tenant_id, real_db_name, database_id));

OX (object_db_id = database_id);

OX (object_name = routine_name);

GET_STANDALONE_ROUTINE();

TRY_SYNONYM(routine_name);

if (OB_SUCC(ret) && need_try_synonym) {

GET_STANDALONE_ROUTINE();

if (OB_SUCC(ret) && OB_ISNULL(routine_info) && OB_NOT_NULL(resolve_ctx)) {

// try dblink synonym

ObString tmp_name = object_name;

ObString full_object_name = tmp_name.split_on('@');

if (full_object_name.empty()) {

// not a dblink

} else {

ObString remote_db_name = full_object_name.split_on('.');

OZ (resolve_ctx->package_guard_.dblink_guard_.get_routine_infos_with_synonym(resolve_ctx->session_info_,

resolve_ctx->schema_guard_, tmp_name, remote_db_name, ObString(""), full_object_name, routines));

}

}

}

} else { // try package routines

OZ (schema_checker.get_database_id(tenant_id, real_db_name, database_id));

OX (object_db_id = database_id);

OX (object_name = package_name);

if (OB_FAIL(ret)) {

} else if (OB_FAIL(schema_checker.get_package_id( // try user package now!

tenant_id, object_db_id, object_name, compatible_mode, package_id))

|| OB_INVALID_ID == package_id) {

if (OB_FAIL(schema_checker.get_udt_id( // try user type now!

tenant_id, object_db_id, OB_INVALID_ID, object_name, package_id))

|| OB_INVALID_ID == package_id) {

bool need_try_synonym = false;

TRY_SYNONYM(package_name);

if (OB_SUCC(ret) && need_try_synonym) {

if (OB_FAIL(schema_checker.get_package_id( // try synonym user package now!

tenant_id, object_db_id, object_name, compatible_mode, package_id))

|| OB_INVALID_ID == package_id) {

if ((is_sys_database_id(object_db_id)

&& OB_FAIL(schema_checker.get_package_id(OB_SYS_TENANT_ID, object_db_id, object_name, compatible_mode, package_id)))

|| OB_INVALID_ID == package_id) {

if (OB_FAIL(schema_checker.get_udt_id( // try synonym user type now!

tenant_id, object_db_id, OB_INVALID_ID, object_name, package_id))

|| OB_INVALID_ID == package_id) {

LOG_WARN("failed to get package id", K(ret));

} else { // it`s user udt, get udt routines

OZ (schema_checker.get_udt_routine_infos(

tenant_id, object_db_id, package_id, routine_name, routine_type, routines));

}

} else { // it`s user pacakge, get package routines

OZ (schema_checker.get_package_routine_infos(

tenant_id, package_id, object_db_id, routine_name, routine_type, routines));

}

} else { // it`s user pacakge, get package routines

OZ (schema_checker.get_package_routine_infos(

tenant_id, package_id, object_db_id, routine_name, routine_type, routines));

}

}

} else { // it`s user udt, get udt routines

OZ (schema_checker.get_udt_routine_infos(

tenant_id, object_db_id, package_id, routine_name, routine_type, routines));

}

} else { // it`s user pacakge, get package routines

OZ (schema_checker.get_package_routine_infos(

tenant_id, package_id, object_db_id, routine_name, routine_type, routines));

}

// try system package or udt

if (OB_FAIL(ret) || OB_INVALID_ID == package_id) {

if (lib::is_oracle_mode() && (db_name.empty()

|| 0 == db_name.case_compare(OB_SYS_DATABASE_NAME)

|| 0 == db_name.case_compare(OB_ORA_SYS_SCHEMA_NAME))) {

if (OB_FAIL(schema_checker.get_package_id( // try system pacakge

OB_SYS_TENANT_ID, OB_SYS_DATABASE_NAME, object_name, compatible_mode, package_id))

|| OB_INVALID_ID == package_id) {

if (OB_FAIL(schema_checker.get_udt_id( // try system udt

OB_SYS_TENANT_ID, OB_SYS_DATABASE_NAME, object_name, package_id))

|| OB_INVALID_ID == package_id) {

LOG_WARN("failed to get package id", K(ret));

} else { // it`s system udt, get udt routines

OZ (schema_checker.get_udt_routine_infos(OB_SYS_TENANT_ID,

package_id, OB_SYS_DATABASE_NAME, routine_name, routine_type, routines));

}

} else { // it`s system pacakge, get package rotuiens.

OZ (schema_checker.get_package_routine_infos(OB_SYS_TENANT_ID,

package_id, OB_SYS_DATABASE_NAME, routine_name, routine_type, routines));

}

} else if (lib::is_mysql_mode()) { // mysql mode only has system package

if (OB_FAIL(schema_checker.get_package_id( // try system pacakge

OB_SYS_TENANT_ID, OB_SYS_DATABASE_NAME, object_name, compatible_mode, package_id))

|| OB_INVALID_ID == package_id) {

LOG_WARN("failed to get package id", K(ret));

} else {

OZ (schema_checker.get_package_routine_infos(OB_SYS_TENANT_ID,

package_id, OB_SYS_DATABASE_NAME, routine_name, routine_type, routines));

}

}

// get routine failed, print parameters for debug.

if (OB_FAIL(ret) || OB_INVALID_ID == package_id) {

LOG_WARN("failed to get routines",

K(ret), K(current_database), K(db_name), K(package_name), K(real_db_name),

K(routine_name), K(routine_type), K(object_name), K(object_db_id));

}

}

}

#undef TRY_SYNONYM

return ret;

}

#define IS_NUMRIC_TYPE(type) \

(ob_is_int_tc(type) \

|| ob_is_uint_tc(type) \

|| ob_is_float_tc(type) \

|| ob_is_double_tc(type) \

|| ob_is_number_tc(type) \

|| ob_is_decimal_int_tc(type))

int ObResolverUtils::check_type_match(ObResolverParams &params,

ObRoutineMatchInfo::MatchInfo &match_info,

ObRawExpr *expr,

ObObjType src_type,

uint64_t src_type_id,

ObPLDataType &dst_pl_type)

{

int ret = OB_SUCCESS;

ObPLPackageGuard package_guard(params.session_info_->get_effective_tenant_id());

ObPLResolveCtx resolve_ctx(*(params.allocator_),

*(params.session_info_),

*(params.schema_checker_->get_schema_guard()),

package_guard,

*(params.sql_proxy_),

false);

OZ (package_guard.init());

OZ (check_type_match(

resolve_ctx, match_info, expr, src_type, src_type_id, dst_pl_type));

return ret;

}

int ObResolverUtils::check_type_match(const pl::ObPLResolveCtx &resolve_ctx,

ObRoutineMatchInfo::MatchInfo &match_info,

ObRawExpr *expr,

ObObjType src_type,

uint64_t src_type_id,

ObPLDataType &dst_pl_type)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(expr));

if (OB_FAIL(ret)) {

// do nothing ...

} else if (T_QUESTIONMARK == expr->get_expr_type()

&& (resolve_ctx.is_prepare_protocol_

|| !resolve_ctx.is_sql_scope_

|| resolve_ctx.session_info_.get_pl_context() != NULL)

&& (ObUnknownType == expr->get_result_type().get_type()

|| ObNullType == expr->get_result_type().get_type()

|| (is_oracle_mode() ? expr->get_result_type().is_oracle_question_mark_type()

: expr->get_result_type().is_mysql_question_mark_type()))) {

OX (match_info =

(ObRoutineMatchInfo::MatchInfo(false,

ObUnknownType,

dst_pl_type.get_obj_type())));

} else if (T_NULL == expr->get_expr_type()

|| ObNullTC == ob_obj_type_class(src_type)) {

// NULL可以匹配任何类型

OX (match_info =

(ObRoutineMatchInfo::MatchInfo(false,

dst_pl_type.get_obj_type(),

dst_pl_type.get_obj_type())));

} else {

if (T_REF_QUERY == expr->get_expr_type() && !dst_pl_type.is_cursor_type()) {

const ObQueryRefRawExpr *query_expr = static_cast<const ObQueryRefRawExpr*>(expr);

CK (OB_NOT_NULL(query_expr));

if (OB_SUCC(ret) && 1 != query_expr->get_output_column()) {

ret = OB_ERR_TOO_MANY_VALUES;

LOG_WARN("subquery return too many columns", K(ret), KPC(query_expr));

}

}

ObCollationType src_coll_type = expr->get_result_type().get_collation_type();

if (OB_SUCC(ret)

&& dst_pl_type.is_cursor_type()

&& expr->get_result_type().get_extend_type() != ObPLType::PL_REF_CURSOR_TYPE

&& expr->get_expr_type() != T_REF_QUERY) {

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("PLS-00382: expression is of wrong type",

K(ret), K(src_type_id), K(dst_pl_type), K(src_type),

K(expr->get_result_type().get_extend_type()),

KPC(expr));

}

if (OB_FAIL(ret)) {

} else if ((ObLobType == src_type || ObLongTextType == src_type)

&& (ObLobType == dst_pl_type.get_obj_type()

|| ObLongTextType == dst_pl_type.get_obj_type())) {

if (src_coll_type

== dst_pl_type.get_meta_type()->get_collation_type()

|| (src_coll_type != CS_TYPE_BINARY

&& dst_pl_type.get_meta_type()->get_collation_type() != CS_TYPE_BINARY)) {

OX (match_info =

(ObRoutineMatchInfo::MatchInfo(

false, dst_pl_type.get_obj_type(), dst_pl_type.get_obj_type())));

} else {

// BLOB和CLOB不能隐式转换, 如果LOB类型不同, 直接淘汰掉

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("PLS-00382: expression is of wrong type",

K(ret), K(src_type_id), K(dst_pl_type), K(src_type));

}

} else if (((ObLobType == src_type || ObLongTextType == src_type)\

&& CS_TYPE_BINARY == src_coll_type)

|| ((ObLobType == dst_pl_type.get_obj_type()

|| ObLongTextType == dst_pl_type.get_obj_type())

&& CS_TYPE_BINARY == dst_pl_type.get_meta_type()->get_collation_type())) {

if (ObRawType == src_type || ObRawType == dst_pl_type.get_obj_type()) {

// Raw and Blob can matched!

OX (match_info =

(ObRoutineMatchInfo::MatchInfo(true, src_type, dst_pl_type.get_obj_type())));

} else {

// BLOB不能向其他类型转, 其他类型也不能向Blob转, 因此是Blob直接淘汰

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("PLS-00382: expression is of wrong type",

K(ret), K(src_type_id), K(dst_pl_type), K(src_type));

}

} else {

OZ (check_type_match(

resolve_ctx, match_info, expr, src_type, src_coll_type, src_type_id, dst_pl_type));

}

LOG_DEBUG("debug for check type match:",

K(src_type), K(src_type_id), K(dst_pl_type), K(match_info), KPC(expr));

}

return ret;

}

int ObResolverUtils::check_type_match(const pl::ObPLResolveCtx &resolve_ctx,

ObRoutineMatchInfo::MatchInfo &match_info,

ObRawExpr *expr,

ObObjType src_type,

ObCollationType src_coll_type,

uint64_t src_type_id,

ObPLDataType &dst_pl_type)

{

int ret = OB_SUCCESS;

#define OBJ_TO_TYPE_CLASS(type) \

(ObRawTC == ob_obj_type_class(type) ? ObStringTC : ob_obj_type_class(type))

ObObjType dst_type = dst_pl_type.get_obj_type();

// Case1: 处理BOOLEAN类型, BOOLEAN类型仅能匹配BOOLEAN

if (lib::is_oracle_mode() && (ObTinyIntType == dst_type || ObTinyIntType == src_type)) {

if (dst_type == src_type) {

OX (match_info = (ObRoutineMatchInfo::MatchInfo(false, src_type, dst_type)));

} else {

ret = OB_ERR_EXPRESSION_WRONG_TYPE;

LOG_WARN("PLS-00382: expression is of wrong type",

K(ret), K(src_type_id), K(dst_pl_type), K(dst_type), K(src_type));

}

// Case2: 处理TypeClass相同的情形

} else if (OBJ_TO_TYPE_CLASS(src_type) == OBJ_TO_TYPE_CLASS(dst_type)) {

if (ob_obj_type_class(src_type) != ObExtendTC // 普通类型TypeClass相同

|| src_type_id == dst_pl_type.get_user_type_id()) { // 复杂类型TypeID相同

OX (match_info =

(ObRoutineMatchInfo::MatchInfo(

ObLongTextType == dst_type ? true : false,

(ObRawType == src_type || ObRawType == dst_type) ? src_type : dst_type,

dst_type)));

} else if (dst_pl_type.is_cursor_type()) {

// TODO: check cursor type compatible

OX (match_info = (ObRoutineMatchInfo::MatchInfo(false, src_type, dst_type)));

} else if (resolve_ctx.is_prepare_protocol_ &&

ObExtendType == src_type &&

OB_INVALID_ID == src_type_id &&

T_QUESTIONMARK == expr->get_expr_type()) { // 匿名数组

const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(expr);

int64_t idx = const_expr->get_value().get_unknown();

CK (OB_NOT_NULL(resolve_ctx.params_.param_list_));

CK (idx < resolve_ctx.params_.param_list_->count());

if (OB_SUCC(ret)) {

const ObObjParam &param = resolve_ctx.params_.param_list_->at(idx);

const pl::ObPLComposite *src_composite = NULL;

CK (OB_NOT_NULL(src_composite = reinterpret_cast<const ObPLComposite *>(param.get_ext())));

if (OB_FAIL(ret)) {

} else if (!dst_pl_type.is_collection_type()) {

ret = OB_ERR_EXPRESSION_WRONG_TYPE;

LOG_WARN("incorrect argument type", K(ret));

} else {

const pl::ObPLCollection *src_coll = NULL;

ObPLResolveCtx pl_resolve_ctx(resolve_ctx.allocator_,

resolve_ctx.session_info_,

resolve_ctx.schema_guard_,

resolve_ctx.package_guard_,

resolve_ctx.sql_proxy_,

false);

const pl::ObUserDefinedType *pl_user_type = NULL;

const pl::ObCollectionType *coll_type = NULL;

OZ (pl_resolve_ctx.get_user_type(dst_pl_type.get_user_type_id(), pl_user_type));

CK (OB_NOT_NULL(coll_type = static_cast<const ObCollectionType *>(pl_user_type)));

CK (OB_NOT_NULL(src_coll = static_cast<const ObPLCollection *>(src_composite)));

if (OB_FAIL(ret)) {

} else if (coll_type->get_element_type().is_obj_type() ^

src_coll->get_element_desc().is_obj_type()) {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("incorrect argument type, diff type",

K(ret), K(coll_type->get_element_type()), K(src_coll->get_element_desc()));

} else if (coll_type->get_element_type().is_obj_type()) { // basic data type

const ObDataType *src_data_type = &src_coll->get_element_desc();

const ObDataType *dst_data_type = coll_type->get_element_type().get_data_type();

if (dst_data_type->get_obj_type() == src_data_type->get_obj_type()) {

// do nothing

} else if (cast_supported(src_data_type->get_obj_type(),

src_data_type->get_collation_type(),

dst_data_type->get_obj_type(),

dst_data_type->get_collation_type())) {

// do nothing

} else {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("incorrect argument type, diff type", K(ret));

}

} else {

// element is composite type

uint64_t element_type_id = src_coll->get_element_desc().get_udt_id();

bool is_compatible = element_type_id == coll_type->get_element_type().get_user_type_id();

if (!is_compatible) {

OZ (ObPLResolver::check_composite_compatible(

NULL == resolve_ctx.params_.secondary_namespace_

? static_cast<const ObPLINS&>(resolve_ctx)

: static_cast<const ObPLINS&>(*resolve_ctx.params_.secondary_namespace_),

element_type_id, coll_type->get_element_type().get_user_type_id(), is_compatible));

}

if (OB_SUCC(ret) && !is_compatible) {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("incorrect argument type",

K(ret), K(element_type_id), K(dst_pl_type), KPC(src_coll));

}

}

OX (match_info = (ObRoutineMatchInfo::MatchInfo(false, src_type, dst_type)));

}

}

} else {

// 复杂类型的TypeClass相同, 需要检查兼容性

bool is_compatible = false;

OZ (ObPLResolver::check_composite_compatible(

NULL == resolve_ctx.params_.secondary_namespace_

? static_cast<const ObPLINS&>(resolve_ctx)

: static_cast<const ObPLINS&>(*resolve_ctx.params_.secondary_namespace_),

src_type_id,

dst_pl_type.get_user_type_id(),

is_compatible), K(src_type_id), K(dst_pl_type), K(resolve_ctx.params_.is_execute_call_stmt_));

if (OB_FAIL(ret)) {

} else if (is_compatible) {

OX (match_info = ObRoutineMatchInfo::MatchInfo(true, src_type, dst_type));

} else {

ret = OB_ERR_EXPRESSION_WRONG_TYPE;

LOG_WARN("PLS-00382: expression is of wrong type",K(ret), K(src_type_id), K(dst_pl_type));

}

}

// Case3: 处理TypeClass不同的情形

} else {

// xmltype can not cast with varchar,

if ((ObExtendTC == ob_obj_type_class(src_type)

&& !(ObUserDefinedSQLTC == ob_obj_type_class(dst_type)

|| ObExtendTC == ob_obj_type_class(dst_type)))

|| (ObUserDefinedSQLTC == ob_obj_type_class(src_type)

&& !(ObUserDefinedSQLTC == ob_obj_type_class(dst_type)

|| ObExtendTC == ob_obj_type_class(dst_type)))

|| ((ObUserDefinedSQLTC == ob_obj_type_class(dst_type)

|| ObExtendTC == ob_obj_type_class(dst_type))

&& !(ObUserDefinedSQLTC == ob_obj_type_class(src_type)

|| ObExtendTC == ob_obj_type_class(src_type)))) {

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("argument count not match", K(ret), K(src_type), K(dst_type));

} else if (ObExtendTC == ob_obj_type_class(src_type) // 普通类型与复杂类型不能互转

|| ObExtendTC == ob_obj_type_class(dst_type)) {

if (ObUserDefinedSQLTC == ob_obj_type_class(src_type)

|| ObUserDefinedSQLTC == ob_obj_type_class(dst_type)) {

// check can cast

} else {

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("argument count not match", K(ret), K(src_type), K(dst_type));

}

} else { // 检查普通类型之间是否可以互转

if (lib::is_oracle_mode()) {

OZ (ObObjCaster::can_cast_in_oracle_mode(dst_type,

dst_pl_type.get_meta_type()->get_collation_type(), src_type, src_coll_type));

} else if (!cast_supported(

src_type, src_coll_type, dst_type, dst_pl_type.get_meta_type()->get_collation_type())) {

ret = OB_ERR_INVALID_TYPE_FOR_OP;

LOG_WARN("inconsistent datatypes",

K(ret), K(src_type), K(src_coll_type),

K(dst_type), K(dst_pl_type.get_meta_type()->get_collation_type()));

}

}

bool is_numric_type = (IS_NUMRIC_TYPE(src_type) && IS_NUMRIC_TYPE(dst_type));

OX (match_info = ObRoutineMatchInfo::MatchInfo(

is_numric_type ? false : true, is_numric_type ? src_type : dst_type, dst_type));

LOG_DEBUG("need cast",

K(ret),

K(src_type),

K(dst_type),

K(ob_obj_type_class(src_type)),

K(ob_obj_type_class(dst_type)));

}

#undef OBJ_TO_TYPE_CLASS

return ret;

}

int ObResolverUtils::get_type_and_type_id(

ObRawExpr *expr, ObObjType &type, uint64_t &type_id)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(expr));

OX (type_id = expr->get_result_type().get_expr_udt_id());

if (OB_FAIL(ret)) {

} else if (IS_BOOL_OP(expr->get_expr_type())) {

type = ObTinyIntType;

} else if (T_FUN_PL_INTEGER_CHECKER == expr->get_expr_type()) {

type = ObInt32Type;

} else {

type = expr->get_result_type().get_type();

}

CK (is_valid_obj_type(type));

return ret;

}

// 检查当前参数是否与当前routine匹配

int ObResolverUtils::check_match(const pl::ObPLResolveCtx &resolve_ctx,

const common::ObIArray<ObRawExpr *> &expr_params,

const ObIRoutineInfo *routine_info,

ObRoutineMatchInfo &match_info)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(routine_info));

if (OB_FAIL(ret)) {

} else if (expr_params.count() > routine_info->get_param_count()) {

ret = OB_ERR_SP_WRONG_ARG_NUM;

LOG_WARN("argument count not match",

K(ret), K(expr_params.count()), K(routine_info->get_param_count()));

}

OX (match_info.routine_info_ = routine_info);

// MatchInfo初始化

for (int64_t i = 0; OB_SUCC(ret) && i < routine_info->get_param_count(); ++i) {

OZ (match_info.match_info_.push_back(ObRoutineMatchInfo::MatchInfo()));

}

int64_t offset = 0;

if (OB_FAIL(ret)) {

} else if (0 == expr_params.count() && routine_info->is_udt_routine() && !routine_info->is_udt_static_routine()) {

// set first param matched

OX (match_info.match_info_.at(0) = (ObRoutineMatchInfo::MatchInfo(false, ObExtendType, ObExtendType)));

OX (offset = 1);

} else if(expr_params.count() > 0 && OB_NOT_NULL(expr_params.at(0))) {

ObRawExpr *first_arg = expr_params.at(0);

if (first_arg->has_flag(IS_UDT_UDF_SELF_PARAM)) {

// do nothing, may be we can check if routine is static or not

} else if (routine_info->is_udt_cons()) {

if (expr_params.count() > 0 && 1 == routine_info->get_param_count()) {

ret = OB_ERR_SP_WRONG_ARG_NUM;

LOG_WARN("argument count not match",

K(ret), K(expr_params.count()), K(routine_info->get_param_count()));

} else {

// construct function & no self real paremeter

OX (match_info.match_info_.at(0) = (ObRoutineMatchInfo::MatchInfo(false, ObExtendType, ObExtendType)));

OX (offset = 1);

}

} else if (routine_info->is_udt_routine()

&& !routine_info->is_udt_static_routine()) {

uint64_t src_type_id = OB_INVALID_ID;

ObObjType src_type;

if (T_SP_CPARAM == first_arg->get_expr_type()) {

ObCallParamRawExpr *call_expr = static_cast<ObCallParamRawExpr*>(first_arg);

OZ (call_expr->get_expr()->extract_info());

OZ (call_expr->get_expr()->deduce_type(&resolve_ctx.session_info_));

OZ (get_type_and_type_id(call_expr->get_expr(), src_type, src_type_id));

} else {

OZ (first_arg->extract_info());

OZ (first_arg->deduce_type(&resolve_ctx.session_info_));

OZ (get_type_and_type_id(first_arg, src_type, src_type_id));

}

if (OB_SUCC(ret)

&& (src_type_id != routine_info->get_package_id())) {

// set first param matched

OX (match_info.match_info_.at(0) = (ObRoutineMatchInfo::MatchInfo(false, src_type, src_type)));

if ((expr_params.count() + 1) > routine_info->get_param_count()) {

ret = OB_ERR_SP_WRONG_ARG_NUM;

LOG_WARN("argument count not match",

K(ret),

K(expr_params.count()),

K(src_type_id),

KPC(first_arg),

K(routine_info->get_param_count()),

K(routine_info->get_routine_name()));

} else {

OX (offset = 1);

}

}

}

}

// 解析参数表达式数组

bool has_assign_param = false;

int arg_cnt = routine_info->get_param_count();

for (int64_t i = 0; OB_SUCC(ret) && offset < arg_cnt && i < expr_params.count(); ++i) {

int64_t position = OB_INVALID_ID;

ObObjType src_type;

uint64_t src_type_id;

ObPLDataType dst_pl_type;

ObRawExpr* expr = NULL;

CK (OB_NOT_NULL(expr_params.at(i)));

if (OB_FAIL(ret)) {

} else if (T_SP_CPARAM == expr_params.at(i)->get_expr_type()) {

ObCallParamRawExpr* call_expr = static_cast<ObCallParamRawExpr*>(expr_params.at(i));

OX (has_assign_param = true);

CK (OB_NOT_NULL(call_expr) && OB_NOT_NULL(call_expr->get_expr()));

OZ (call_expr->get_expr()->extract_info());

OZ (call_expr->get_expr()->deduce_type(&resolve_ctx.session_info_));

CK (!call_expr->get_name().empty());

OZ (routine_info->find_param_by_name(call_expr->get_name(), position));

OX (expr = call_expr->get_expr());

OZ (get_type_and_type_id(call_expr->get_expr(), src_type, src_type_id));

} else if (has_assign_param) {

ret = OB_ERR_POSITIONAL_FOLLOW_NAME;

LOG_WARN("can not set param without assign after param with assign",

K(ret), K(i), K(expr_params), K(match_info));

} else {

OZ (expr_params.at(i)->extract_info());

OZ (expr_params.at(i)->deduce_type(&resolve_ctx.session_info_));