/**

* 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

#include "ob_spi.h"

#include "ob_sql.h"

#include "common/sql_mode/ob_sql_mode_utils.h"

#include "ob_sql_utils.h"

#include "observer/ob_inner_sql_connection_pool.h"

#include "observer/ob_inner_sql_connection.h"

#include "observer/ob_inner_sql_result.h"

#include "observer/ob_server_struct.h"

#include "observer/mysql/ob_query_retry_ctrl.h"

#include "observer/mysql/ob_sync_cmd_driver.h"

#include "sql/parser/ob_parser.h"

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

#include "sql/resolver/ob_stmt_resolver.h"

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

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

#include "pl/ob_pl_package.h"

#include "pl/ob_pl_allocator.h"

#include "sql/resolver/ob_resolver_utils.h"

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

#include "sql/code_generator/ob_expr_generator_impl.h"

#include "sql/ob_result_set.h"

#include "sql/parser/parse_node.h"

#include "pl/ob_pl_exception_handling.h"

#include "sql/plan_cache/ob_ps_cache.h"

#include "storage/tx/ob_trans_service.h"

#include "pl/sys_package/ob_dbms_sql.h"

#include "pl/ob_pl.h"

#include "sql/dblink/ob_tm_service.h"

#ifdef OB_BUILD_ORACLE_PL

#include "pl/dblink/ob_pl_dblink_util.h"

#endif

#include "pl/ob_pl_allocator.h"

namespace oceanbase

{

using namespace sqlclient;

using namespace common;

using namespace share;

using namespace observer;

using namespace pl;

using namespace share::schema;

namespace sql

{

#define SET_SPI_STATUS \

do { \

if (OB_ISNULL(ctx->status_)) { \

ret = OB_SUCCESS == ret ? OB_INVALID_ARGUMENT : ret; \

LOG_WARN("status in is NULL", K(ctx->status_), K(ret)); \

} else { \

*ctx->status_ = ret; \

} \

} while (0)

#define SET_FORALL_BULK_EXCEPTION \

do { \

if (OB_FAIL(ret)) { \

ObPLCursorInfo* cursor = NULL; \

if (OB_ISNULL(ctx) \

|| OB_ISNULL(ctx->exec_ctx_) \

|| OB_ISNULL(ctx->exec_ctx_->get_my_session()) \

|| OB_ISNULL(cursor = ctx->exec_ctx_->get_my_session()->get_pl_implicit_cursor())) { \

/*don`t change error code, so do nothing*/ \

} else if (OB_BATCHED_MULTI_STMT_ROLLBACK == ret) { \

/*forall optimal rollback, forall will rollback to single sql mode*/ \

cursor->set_forall_rollback(); \

} else if (!cursor->get_in_forall() \

|| !cursor->get_save_exception() \

/*|| !cursor->is_forall_rollback()*/) { \

/*not in forall or in forall rollback, do nothing*/ \

/*we just handle bulk exception in single sql mode*/ \

} else if (OB_SUCCESS != cursor->set_bulk_exception(ret)) { \

LOG_WARN("failed to set bulk exception"); \

} else { \

ret = OB_SUCCESS; \

} \

} \

} while (0)

int ObSPIService::PLPrepareResult::init(sql::ObSQLSessionInfo &session_info)

{

int ret = OB_SUCCESS;

lib::ContextParam param;

param.set_mem_attr(session_info.get_effective_tenant_id(),

ObModIds::OB_PL_TEMP,

ObCtxIds::DEFAULT_CTX_ID)

.set_properties(lib::USE_TL_PAGE_OPTIONAL)

.set_page_size(OB_MALLOC_MIDDLE_BLOCK_SIZE)

.set_ablock_size(lib::INTACT_MIDDLE_AOBJECT_SIZE);

if (OB_FAIL(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context_, param))) {

LOG_WARN("create memory entity failed", K(ret));

} else {

result_set_ = new (buf_) ObResultSet(session_info, mem_context_->get_arena_allocator());

}

return ret;

}

int ObSPIResultSet::init(sql::ObSQLSessionInfo &session_info)

{

int ret = OB_SUCCESS;

lib::ContextParam param;

param.set_mem_attr(session_info.get_effective_tenant_id(),

ObModIds::OB_RESULT_SET,

ObCtxIds::DEFAULT_CTX_ID)

.set_properties(lib::USE_TL_PAGE_OPTIONAL)

.set_page_size(OB_MALLOC_MIDDLE_BLOCK_SIZE)

.set_ablock_size(lib::INTACT_MIDDLE_AOBJECT_SIZE);

if (OB_FAIL(CURRENT_CONTEXT->CREATE_CONTEXT(mem_context_, param))) {

LOG_WARN("create memory entity failed", K(ret));

} else {

result_set_ = new (buf_) ObResultSet(session_info, mem_context_->get_arena_allocator());

is_inited_ = true;

result_set_->get_exec_context().get_task_exec_ctx().set_min_cluster_version(session_info.get_exec_min_cluster_version());

}

return ret;

}

int ObSPIResultSet::close_result_set()

{

int ret = OB_SUCCESS;

if (is_inited_) {

WITH_CONTEXT(mem_context_) {

ret = result_set_->close();

}

} else {

LOG_INFO("result set is not init", K(ret));

}

return ret;

}

int ObSPIResultSet::destruct_exec_params(ObSQLSessionInfo &session)

{

int ret = OB_SUCCESS;

if (NULL != get_result_set()

&& NULL != get_result_set()->get_exec_context().get_physical_plan_ctx()) {

ParamStore &params = get_result_set()->get_exec_context().get_physical_plan_ctx()->get_param_store_for_update();

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

OZ (ObUserDefinedType::destruct_obj(params.at(i), &session));

}

}

return ret;

}

int ObSPIResultSet::store_session(ObSQLSessionInfo *session,

sql::ObSQLSessionInfo::StmtSavedValue *&value,

int64_t &nested_count)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(session));

OZ (alloc_saved_value(value));

CK (OB_NOT_NULL(value));

OZ (session->save_session(*value));

OX (nested_count = session->get_nested_count());

OX (session->set_query_start_time(ObTimeUtility::current_time()));

return ret;

}

int ObSPIResultSet::restore_session(ObSQLSessionInfo *session,

sql::ObSQLSessionInfo::StmtSavedValue *value,

int64_t nested_count)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(session));

CK (OB_NOT_NULL(value));

OZ (session->restore_session(*value));

OX (session->set_nested_count(nested_count));

return ret;

}

int ObSPIResultSet::store_orign_session(ObSQLSessionInfo *session)

{

return store_session(session, orign_session_value_, orign_nested_count_);

}

int ObSPIResultSet::store_cursor_session(ObSQLSessionInfo *session)

{

return store_session(session, cursor_session_value_, cursor_nested_count_);

}

int ObSPIResultSet::restore_orign_session(ObSQLSessionInfo *session)

{

return ObSPIResultSet::restore_session(session, orign_session_value_, orign_nested_count_);

}

int ObSPIResultSet::restore_cursor_session(ObSQLSessionInfo *session)

{

return restore_session(session, cursor_session_value_, cursor_nested_count_);

}

int ObSPIResultSet::begin_nested_session(ObSQLSessionInfo &session)

{

int ret = OB_SUCCESS;

OZ (alloc_saved_value(nested_session_value_));

OV (OB_NOT_NULL(nested_session_value_));

OZ (session.begin_nested_session(*nested_session_value_));

return ret;

}

int ObSPIResultSet::end_nested_session(ObSQLSessionInfo &session)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(nested_session_value_));

OZ (session.end_nested_session(*nested_session_value_));

return ret;

}

int ObSPIResultSet::alloc_saved_value(sql::ObSQLSessionInfo::StmtSavedValue *&session_value)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(session_value)) {

void *ptr = NULL;

if (OB_ISNULL(ptr = allocator_.alloc(sizeof(sql::ObSQLSessionInfo::StmtSavedValue)))) {

ret = OB_ALLOCATE_MEMORY_FAILED;

LOG_WARN("failed to alloc memory for saved session value", K(ret));

}

CK (OB_NOT_NULL(session_value = new(ptr)sql::ObSQLSessionInfo::StmtSavedValue()));

}

return ret;

}

int ObSPIResultSet::is_set_global_var(ObSQLSessionInfo &session, const ObString &sql, bool &has_global_variable)

{

int ret = OB_SUCCESS;

has_global_variable = false;

ObArenaAllocator allocator(GET_PL_MOD_STRING(PL_MOD_IDX::OB_PL_SET_VAR), OB_MALLOC_NORMAL_BLOCK_SIZE, MTL_ID());

ParseResult parse_result;

ParseMode parse_mode = STD_MODE;

ObParser parser(allocator, session.get_sql_mode(), session.get_charsets4parser());

if (sql.empty()) {

} else if (OB_FAIL(parser.parse(sql,

parse_result,

parse_mode,

false/*is_batched_multi_stmt_split_on*/,

false/*no_throw_parser_error*/,

true))) {

LOG_WARN("generate syntax tree failed", K(sql), K(ret));

} else if (OB_NOT_NULL(parse_result.result_tree_) &&

parse_result.result_tree_->num_child_ > 0 &&

OB_NOT_NULL(parse_result.result_tree_->children_[0])) {

ParseNode *set_node = NULL;

ParseNode *parse_tree = parse_result.result_tree_->children_[0];

for (int64_t i = 0; OB_SUCC(ret) && !has_global_variable && i < parse_tree->num_child_; ++i) {

if (OB_ISNULL(set_node = parse_tree->children_[i])) {

ret = OB_ERR_UNEXPECTED;

LOG_ERROR("set node is NULL", K(ret));

} else if (T_VAR_VAL == set_node->type_ &&

1 == set_node->value_) { // global var

has_global_variable = true;

} else if (set_node->num_child_ > 0 && OB_NOT_NULL(set_node->children_[0])) {

ParseNode *var = set_node->children_[0];

ObString name;

if (T_OBJ_ACCESS_REF == var->type_) { //Oracle mode

const ParseNode *name_node = NULL;

if (OB_ISNULL(name_node = var->children_[0])) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("get unexpected null", K(ret));

} else {

name.assign_ptr(name_node->str_value_, static_cast<int32_t>(name_node->str_len_));

}

} else if (T_SYSTEM_VARIABLE == var->type_) {

name.assign_ptr(var->str_value_, static_cast<int32_t>(var->str_len_));

}

if (OB_SUCC(ret) && 0 == name.case_compare("ob_query_timeout")) {

has_global_variable = true;

}

}

}

}

return ret;

}

int ObSPIResultSet::check_nested_stmt_legal(ObExecContext &exec_ctx, const ObString &sql, stmt::StmtType stmt_type, bool for_update)

{

int ret = OB_SUCCESS;

bool has_global_variable = false;

stmt::StmtType parent_stmt_type = stmt::T_NONE;

ObSqlCtx *sql_ctx = exec_ctx.get_sql_ctx();

ObPLContext *pl_ctx = exec_ctx.get_pl_stack_ctx();

if (OB_ISNULL(sql_ctx) || OB_ISNULL(pl_ctx)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("invalid sql_ctx or pl_ctx", K(ret), K(sql_ctx), K(pl_ctx));

} else {

parent_stmt_type = sql_ctx->stmt_type_;

LOG_DEBUG("check nested stmt legal", K(parent_stmt_type), K(pl_ctx->in_autonomous()), K(stmt_type));

}

if (stmt::T_VARIABLE_SET == stmt_type && OB_NOT_NULL(exec_ctx.get_my_session())) {

OZ (is_set_global_var(*exec_ctx.get_my_session(), sql, has_global_variable));

}

if (OB_SUCC(ret) && !pl_ctx->in_autonomous() && ObStmt::is_dml_stmt(parent_stmt_type)) {

//only when parent stmt is dml or select, it can trigger a nested sql

if (parent_stmt_type == stmt::T_SELECT && ObStmt::is_dml_write_stmt(stmt_type)) {

/**

* CREATE FUNCTION func() RETURNS VARCHAR(128)

* BEGIN

* INSERT INTO t1 VALUES (4);

* return '隐式提交';

* END

*

* select func() from dual;

* this function is allowed in mysql, but not allowed in oracle

*/

if (!(lib::is_mysql_mode())) {

ret = OB_ERR_CANNOT_PERFORM_DML_INSIDE_QUERY;

LOG_WARN("ORA-14551: cannot perform a DML operation inside a query",

K(ret), K(stmt_type), K(exec_ctx.get_sql_ctx()),

K(&exec_ctx), K(exec_ctx.get_my_session()->get_cur_exec_ctx()));

}

} else if (stmt::T_SELECT == parent_stmt_type && stmt::T_SELECT == stmt_type && for_update && lib::is_oracle_mode()) {

ret = OB_ERR_CANNOT_PERFORM_DML_INSIDE_QUERY;

LOG_WARN("ORA-14551: cannot perform a DML operation inside a query",

K(ret), K(stmt_type), K(exec_ctx.get_sql_ctx()),

K(&exec_ctx), K(exec_ctx.get_my_session()->get_cur_exec_ctx()));

} else if (ObStmt::is_ddl_stmt(stmt_type, has_global_variable) || ObStmt::is_tcl_stmt(stmt_type)) {

ret = lib::is_oracle_mode() ? OB_NOT_SUPPORTED : OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG;

LOG_WARN("ORA-14552: Cannot Perform a DDL Commit or Rollback Inside a Query or DML tips",

K(ret), K(stmt_type), K(lbt()));

if (OB_NOT_SUPPORTED == ret) {

LOG_USER_ERROR(OB_NOT_SUPPORTED, "ORA-14552: Cannot Perform a DDL Commit or Rollback Inside a Query or DML tips");

}

} else if (lib::is_oracle_mode() &&

(stmt::T_CREATE_SAVEPOINT == stmt_type

|| stmt::T_ROLLBACK_SAVEPOINT == stmt_type

|| stmt::T_RELEASE_SAVEPOINT == stmt_type)) {

ret = OB_ERR_CANNOT_PERFORM_DDL_COMMIT_OR_ROLLBACK_INSIDE_QUERY_OR_DML_TIPS;

LOG_WARN("ORA-14552: Cannot Perform a DDL Commit or Rollback Inside a Query or DML tips",

K(ret), K(stmt_type), K(lbt()));

} else {

// do nothing ...

}

}

return ret;

}

int ObSPIResultSet::start_trans(ObExecContext &ctx)

{

// cursor执行之前如果还没有事务, 则开始一个新的事务

int ret = OB_SUCCESS;

ObPhysicalPlanCtx *plan_ctx = GET_PHY_PLAN_CTX(ctx);

ObSQLSessionInfo *my_session = GET_MY_SESSION(ctx);

ObTaskExecutorCtx &task_exec_ctx = ctx.get_task_exec_ctx();

CK (OB_NOT_NULL(plan_ctx), OB_NOT_NULL(my_session));

CK (OB_LIKELY(task_exec_ctx.min_cluster_version_is_valid()));

OZ (ObSqlTransControl::explicit_start_trans(ctx, false));

return ret;

}

int ObSPIResultSet::set_cursor_env(ObSQLSessionInfo &session)

{

int ret = OB_SUCCESS;

OZ (store_orign_session(&session));

OZ (restore_cursor_session(&session));

OX (need_end_nested_stmt_ = EST_RESTORE_SESSION);

return ret;

}

int ObSPIResultSet::reset_cursor_env(ObSQLSessionInfo &session)

{

int ret = OB_SUCCESS;

OZ (store_cursor_session(&session));

OZ (restore_orign_session(&session));

OX (need_end_nested_stmt_ = EST_NEED_NOT);

return ret;

}

int ObSPIResultSet::start_cursor_stmt(

ObPLExecCtx *pl_ctx, stmt::StmtType stmt_type, bool is_for_update)

{

int ret = OB_SUCCESS;

ObSQLSessionInfo *session = NULL;

CK (OB_NOT_NULL(pl_ctx));

CK (OB_NOT_NULL(pl_ctx->exec_ctx_));

CK (OB_NOT_NULL(session = pl_ctx->exec_ctx_->get_my_session()));

if (OB_SUCC(ret)) {

OZ (store_orign_session(session));

OX (need_end_nested_stmt_ = EST_RESTORE_SESSION);

}

LOG_TRACE("call spi start cursor stmt",

K(ret), K(stmt_type),

K(is_for_update),

K(need_end_nested_stmt_),

K(session->get_stmt_type()));

return ret;

}

void ObSPIResultSet::end_cursor_stmt(ObPLExecCtx *pl_ctx, int &result)

{

int ret = OB_SUCCESS;

if (need_end_nested_stmt_ != EST_NEED_NOT) {

ObSQLSessionInfo *session = NULL;

CK (OB_NOT_NULL(pl_ctx));

CK (OB_NOT_NULL(pl_ctx->exec_ctx_));

CK (OB_NOT_NULL(session = pl_ctx->exec_ctx_->get_my_session()));

OZ (reset_cursor_env(*session));

if (OB_SUCC(ret)

&& OB_NOT_NULL(get_result_set())

&& get_out_params().has_out_param()) {

OZ (ObSPIService::process_function_out_result(

pl_ctx, *get_result_set(), get_out_params().get_out_params()));

}

if (OB_FAIL(ret)) {

result = OB_SUCCESS == result ? ret : result;

LOG_WARN("failed to end cursor stmt", K(ret), K(session), K(need_end_nested_stmt_));

}

LOG_TRACE("call spi end cursor stmt", K(ret));

}

return;

}

int ObSPIResultSet::start_nested_stmt_if_need(ObPLExecCtx *pl_ctx, const ObString &sql, stmt::StmtType stmt_type, bool for_update)

{

int ret = OB_SUCCESS;

ObSQLSessionInfo *session = NULL;

CK (OB_NOT_NULL(pl_ctx));

CK (OB_NOT_NULL(pl_ctx->exec_ctx_));

CK (OB_NOT_NULL(session = pl_ctx->exec_ctx_->get_my_session()));

// 如果未发生嵌套, 这里不限制执行语句的类型, 只有在嵌套的情况下才做判断

if (OB_FAIL(ret)) {

// do nothing ...

} else if (OB_NOT_NULL(pl_ctx->exec_ctx_->get_pl_stack_ctx())

&& pl_ctx->exec_ctx_->get_pl_stack_ctx()->in_nested_sql_ctrl()) {

// 嵌套的顶层语句一定是一个DML语句, 并且开启了事务, 此时走fast_select流程

OZ (check_nested_stmt_legal(*pl_ctx->exec_ctx_, sql, stmt_type, for_update));

OZ (begin_nested_session(*session));

OX (session->set_query_start_time(ObTimeUtility::current_time()));

OX (need_end_nested_stmt_ = EST_END_NESTED_SESSION);

LOG_TRACE("call start nested stmt if need", K(ret),

K(stmt_type),

K(need_end_nested_stmt_),

K(session->get_stmt_type()));

}

return ret;

}

void ObSPIResultSet::end_nested_stmt_if_need(ObPLExecCtx *pl_ctx, int &result)

{

int ret = OB_SUCCESS;

if (need_end_nested_stmt_ > EST_NEED_NOT) {

ObSQLSessionInfo *session = NULL;

CK (need_end_nested_stmt_ == EST_RESTORE_SESSION ||

need_end_nested_stmt_ == EST_END_NESTED_SESSION);

CK (OB_NOT_NULL(pl_ctx));

CK (OB_NOT_NULL(pl_ctx->exec_ctx_));

CK (OB_NOT_NULL(session = pl_ctx->exec_ctx_->get_my_session()));

CK (OB_NOT_NULL(pl_ctx->exec_ctx_->get_my_session()->get_pl_context()));

OX (pl_ctx->exec_ctx_->get_my_session()->get_pl_context()->set_exception_handler_illegal());

switch (need_end_nested_stmt_) {

case EST_RESTORE_SESSION:

OZ (restore_orign_session(session));

break;

case EST_END_NESTED_SESSION:

OZ (end_nested_session(*session));

break;

default:

break;

}

OX (need_end_nested_stmt_ = EST_NEED_NOT);

if (OB_FAIL(ret)) {

result = OB_SUCCESS == result ? ret : result;

LOG_WARN("failed to end nested stmt", K(ret));

}

LOG_TRACE("call end nested stmt if need", K(ret));

}

return;

}

bool ObSPIService::can_obj_access_expr_fast_calc(const ObSqlExpression &expr,

const ObExprObjAccess *&obj_access)

{

bool ret = false;

if (is_obj_access_expression(expr)

&& 1 == expr.get_expr_items().count()

&& OB_NOT_NULL(get_first_expr_item(expr).get_expr_operator())

&& T_OBJ_ACCESS_REF == get_first_expr_item(expr).get_expr_operator()->get_type()) {

const ObExprOperator* op = get_first_expr_item(expr).get_expr_operator();

obj_access = static_cast<const ObExprObjAccess*>(op);

if (OB_NOT_NULL(obj_access)) {

ret = true;

}

} else {

obj_access = NULL;

}

return ret;

}

int ObSPIService::calc_obj_access_expr(ObPLExecCtx *ctx,

const ObSqlExpression &expr,

ObObjParam &result)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(ctx));

CK (OB_NOT_NULL(ctx->exec_ctx_));

CK (OB_NOT_NULL(ctx->params_));

CK (OB_NOT_NULL(ctx->allocator_));

if (OB_SUCC(ret)) {

const ObExprObjAccess *obj_access = NULL;

if (1 == expr.get_expr_items().count()) { // 没有入参, 直接计算

CK (OB_NOT_NULL(obj_access =

static_cast<const ObExprObjAccess *>(get_first_expr_item(expr).get_expr_operator())));

OZ(

obj_access->calc_result(result, *ctx->allocator_, NULL, 0, *(ctx->params_)));

} else if (2 == expr.get_expr_items().count()

&& T_OBJ_ACCESS_REF == expr.get_expr_items().at(1).get_item_type()) { // 有一个入参, 且入参是ObjAccessExpr

ObObj first_result;

CK (OB_NOT_NULL(obj_access =

static_cast<const ObExprObjAccess *>(expr.get_expr_items().at(1).get_expr_operator())));

OZ(obj_access->calc_result(first_result, *ctx->allocator_, NULL, 0,

*(ctx->params_)));

CK (OB_NOT_NULL(obj_access =

static_cast<const ObExprObjAccess *>(get_first_expr_item(expr).get_expr_operator())));

OZ(obj_access->calc_result(result, *ctx->allocator_, &first_result, 1,

*(ctx->params_)));

} else { // 其他情况

LOG_DEBUG("calc_obj_access_expr without row", K(expr));

OZ (ObSQLUtils::calc_sql_expression_without_row(*ctx->exec_ctx_, expr, result));

}

result.set_param_meta();

}

return ret;

}

int ObSPIService::spi_pad_char_or_varchar(ObSQLSessionInfo *session_info,

const ObSqlExpression *expr,

ObIAllocator *allocator,

ObObj *result)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(session_info), OB_NOT_NULL(expr), OB_NOT_NULL(allocator), OB_NOT_NULL(result));

if (OB_SUCC(ret)

&& result->is_character_type()

&& is_pad_char_to_full_length(session_info->get_sql_mode())

&& T_FUN_COLUMN_CONV == get_expression_type(*expr)) { //TODO:@ryan.ly padding

const ObSqlFixedArray<ObInfixExprItem>& items = expr->get_expr_items();

CK(T_INT == items.at(3).get_item_type()); // type

CK(T_INT32 == items.at(1).get_item_type()); // accuracy

if (OB_SUCC(ret)) {

const ObObjType type = static_cast<ObObjType>(items.at(1).get_obj().get_int());

ObAccuracy accuracy;

accuracy.set_accuracy(items.at(3).get_obj().get_int());

OZ (spi_pad_char_or_varchar(session_info, type, accuracy, allocator, result));

}

}

return ret;

}

int ObSPIService::spi_pad_char_or_varchar(ObSQLSessionInfo *session_info,

const ObRawExpr *expr,

ObIAllocator *allocator,

ObObj *result)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(session_info), OB_NOT_NULL(expr), OB_NOT_NULL(allocator), OB_NOT_NULL(result));

if (OB_SUCC(ret)

&& result->is_character_type()

&& is_pad_char_to_full_length(session_info->get_sql_mode())

&& T_FUN_COLUMN_CONV == expr->get_expr_type()) { //TODO:@ryan.ly padding

CK (expr->get_param_count() >= ObExprColumnConv::PARAMS_COUNT_WITHOUT_COLUMN_INFO);

if (OB_SUCC(ret)) {

ObAccuracy accuracy;

int32_t data_type = 0;

int64_t accuracy_type = 0;

const ObConstRawExpr *type_expr =

static_cast<const ObConstRawExpr*>(expr->get_param_expr(0));

const ObConstRawExpr *accuracy_expr =

static_cast<const ObConstRawExpr*>(expr->get_param_expr(2));

CK (OB_NOT_NULL(type_expr) && OB_NOT_NULL(accuracy_expr));

OX (type_expr->get_value().get_int32(data_type));

OX (accuracy_expr->get_value().get_int(accuracy_type));

OX (accuracy.set_accuracy(accuracy_type));

OZ (spi_pad_char_or_varchar(session_info, static_cast<ObObjType>(data_type),

accuracy, allocator, result));

}

}

return ret;

}

int ObSPIService::spi_pad_char_or_varchar(ObSQLSessionInfo *session_info,

const ObObjType &type,

const ObAccuracy &accuracy,

ObIAllocator *allocator,

ObObj *result)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(session_info), OB_NOT_NULL(allocator), OB_NOT_NULL(result));

if (OB_SUCC(ret)

&& result->is_character_type()

&& is_pad_char_to_full_length(session_info->get_sql_mode())) {

if (OB_SUCC(ret)) {

if (ObCharType == type || ObNCharType == type) {

int32_t length = accuracy.get_length(); // byte or char length

int32_t cell_strlen = 0; // byte or char length

int32_t pad_whitespace_length = 0; // pad whitespace length

if (OB_FAIL(result->get_char_length(accuracy, cell_strlen, lib::is_oracle_mode()))) {

LOG_WARN("Fail to get char length, ", K(ret));

} else {

if (cell_strlen < length) {

pad_whitespace_length = length - cell_strlen;

}

if (pad_whitespace_length > 0) {

ObString res_string;

if (OB_FAIL(ObCharset::whitespace_padding(*allocator,

result->get_collation_type(),

result->get_string(),

pad_whitespace_length,

res_string))) {

LOG_WARN("whitespace_padding failed", K(ret), K(pad_whitespace_length));

} else {

// watch out !!! in order to deep copy an ObObj instance whose type is char or varchar,

// set_collation_type() should be revoked. But here no need to set collation type

result->set_string(result->get_type(), res_string);

}

}

}

}

}

}

return ret;

}

int ObSPIService::spi_pad_binary(ObSQLSessionInfo *session_info,

const ObAccuracy &accuracy,

ObIAllocator *allocator,

ObObj *result)

{

int ret = OB_SUCCESS;

const ObObjType &type = result->get_type();

CK (OB_NOT_NULL(session_info), OB_NOT_NULL(allocator), OB_NOT_NULL(result));

if (OB_SUCC(ret)

&& result->is_binary()

&& (ObCharType == type || ObNCharType == type)) {

int32_t obj_max_length = accuracy.get_length();

int32_t cell_strlen = result->get_val_len();

int32_t pad_zero_length = 0; // pad '\0' length

if (cell_strlen < obj_max_length) {

pad_zero_length = obj_max_length - cell_strlen;

ObString res_string;

const ObCollationType coll_type = result->get_collation_type();

const ObString &input = result->get_string();

char *buf = NULL;

int32_t buf_len = input.length() + pad_zero_length;

if (OB_UNLIKELY(pad_zero_length <= 0)) {

ret = OB_INVALID_ARGUMENT;

LOG_WARN("invalid len", K(ret), K(pad_zero_length));

} else if (OB_ISNULL(buf = static_cast<char*>(allocator->alloc(buf_len)))) {

ret = OB_ALLOCATE_MEMORY_FAILED;

LOG_WARN("no memory", K(ret), K(buf_len));

} else {

MEMMOVE(buf, input.ptr(), input.length());

MEMSET(buf + input.length(), '\0', pad_zero_length);

res_string = ObString(buf_len, buf_len, buf);

}

result->set_string(result->get_type(), res_string);

}

}

return ret;

}

int ObSPIService::cast_enum_set_to_string(ObExecContext &ctx,

const ObIArray<ObString> &enum_set_values,

ObObjParam &src,

ObObj &result)

{

int ret = OB_SUCCESS;

ObRawExprFactory *expr_factory = ctx.get_expr_factory();

ObSQLSessionInfo *session_info = ctx.get_my_session();

ObConstRawExpr *c_expr = NULL;

ObSysFunRawExpr *out_expr = NULL;

ObExprResType result_type;

CK (OB_NOT_NULL(expr_factory));

CK (OB_NOT_NULL(session_info));

OZ (expr_factory->create_raw_expr(static_cast<ObItemType>(src.get_type()), c_expr));

CK (OB_NOT_NULL(c_expr));

OZ (c_expr->set_enum_set_values(enum_set_values));

OX (c_expr->set_value(src));

OX (result_type.set_meta(src.get_meta()));

OX (result_type.set_accuracy(src.get_accuracy()));

OX (c_expr->set_result_type(result_type));

OZ (ObRawExprUtils::create_type_to_str_expr(*expr_factory, c_expr, out_expr, session_info, true));

CK (OB_NOT_NULL(out_expr));

OZ (ObSPIService::spi_calc_raw_expr(session_info, &(ctx.get_allocator()), out_expr, &result));

return ret;

}

int ObSPIService::spi_calc_raw_expr(ObSQLSessionInfo *session,

ObIAllocator *allocator,

const ObRawExpr *expr,

ObObj *result)

{

int ret = OB_SUCCESS;

ObExecContext *exec_ctx = NULL;

ParamStore param_store((ObWrapperAllocator(*allocator)));

CK (OB_NOT_NULL(result));

OZ (ObSQLUtils::se_calc_const_expr(session, expr, param_store, *allocator, exec_ctx, *result));

OX (result->set_collation_level(expr->get_result_type().get_collation_level()));

OZ (spi_pad_char_or_varchar(session, expr, allocator, result));

return ret;

}

int ObSPIService::spi_convert(ObSQLSessionInfo &session,

ObIAllocator &allocator,

ObObj &src,

const ObExprResType &dst_type,

ObObj &dst,

bool ignore_fail)

{

int ret = OB_SUCCESS;

ObCastMode cast_mode = CM_NONE;

OZ (ObSQLUtils::get_default_cast_mode(stmt::T_NONE, &session, cast_mode));

if (OB_SUCC(ret)) {

if (ignore_fail) {

cast_mode |= CM_WARN_ON_FAIL;

}

bool is_strict = is_strict_mode(session.get_sql_mode());

const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(&session);

ObCastCtx cast_ctx(&allocator, &dtc_params, cast_mode, dst_type.get_collation_type());

if ((dst_type.is_blob() || dst_type.is_blob_locator() || src.is_blob() || src.is_blob_locator()) && lib::is_oracle_mode()) {

cast_ctx.cast_mode_ |= CM_ENABLE_BLOB_CAST;

}

if (dst_type.is_null() || dst_type.is_unknown() || dst_type.is_ext()) {

OX (dst = src);

} else {

OZ (ObExprColumnConv::convert_with_null_check(dst, src, dst_type, is_strict, cast_ctx, NULL));

}

}

return ret;

}

int ObSPIService::spi_convert(ObSQLSessionInfo *session,

ObIAllocator *allocator,

ObObjParam &src,

const ObExprResType &result_type,

ObObjParam &result)

{

int ret = OB_SUCCESS;

ObObj dst;

CK (OB_NOT_NULL(session));

CK (OB_NOT_NULL(allocator));

OZ (spi_convert(*session, *allocator, src, result_type, dst));

OX (src.set_param_meta());

OX (result.set_accuracy(result_type.get_accuracy()));

OX (result.set_meta_type(result_type.get_obj_meta()));

OX (result = dst);

OX (result.set_param_meta());

return ret;

}

int ObSPIService::spi_convert_objparam(ObPLExecCtx *ctx,

ObObjParam *src,

const int64_t result_idx,

ObObjParam *result,

bool need_set)

{

int ret = OB_SUCCESS;

const ObPLDataType *expected_type;

CK (OB_NOT_NULL(ctx));

CK (OB_NOT_NULL(ctx->func_));

CK (OB_NOT_NULL(ctx->exec_ctx_));

CK (OB_NOT_NULL(ctx->params_));

CK (OB_NOT_NULL(ctx->exec_ctx_->get_my_session()));

CK (OB_NOT_NULL(ctx->allocator_));

CK (OB_NOT_NULL(src));

CK (OB_NOT_NULL(result));

CK (ctx->params_->count() == ctx->func_->get_variables().count());

CK (result_idx < ctx->params_->count() && result_idx >= 0);

CK (OB_NOT_NULL(expected_type = &(ctx->func_->get_variables().at(result_idx))));

CK (OB_NOT_NULL(expected_type->get_data_type()));

if (OB_SUCC(ret)) {

ObExprResType result_type;

ObObjParam result_value;

result_type.reset();

result_type.set_meta(expected_type->get_data_type()->get_meta_type());

result_type.set_accuracy(expected_type->get_data_type()->get_accuracy());

if (result_type.is_null()) {

CK (OB_LIKELY(STANDALONE_ANONYMOUS == ctx->func_->get_proc_type()));

OX (result_value = *src);

if (need_set) {

OX (ctx->params_->at(result_idx) = result_value);

}

} else {

OZ (spi_convert(ctx->exec_ctx_->get_my_session(), ctx->allocator_, *src, result_type, result_value));

if (need_set) {

OX (ctx->params_->at(result_idx).apply(result_value));

OX (ctx->params_->at(result_idx).set_param_meta());

}

}

if (OB_NOT_NULL(result)) {

OX (*result = result_value);

}

}

return ret;

}

int ObSPIService::spi_calc_expr(ObPLExecCtx *ctx,

const ObSqlExpression *expr,

const int64_t result_idx,

ObObjParam *result)

{

int ret = OB_SUCCESS;

CK (OB_NOT_NULL(ctx), OB_NOT_NULL(expr), OB_NOT_NULL(result));

CK (OB_NOT_NULL(ctx->exec_ctx_), OB_NOT_NULL(ctx->params_), OB_NOT_NULL(ctx->allocator_), OB_NOT_NULL(ctx->exec_ctx_->get_my_session()));

if (OB_SUCC(ret)) {

ObItemType expr_type = expr->get_expr_items().at(0).get_item_type();

if (IS_CONST_TYPE(expr_type)) {

bool need_check = false;

const ObObj &value = expr->get_expr_items().at(0).get_obj();

if (T_QUESTIONMARK == expr_type) {

OZ (ObSQLUtils::get_param_value<ObObjParam>(value, *ctx->params_, *result, need_check));

} else {

OZ (deep_copy_obj(*ctx->allocator_, value, *result));

result->set_param_meta();

}

} else if (T_OBJ_ACCESS_REF == expr_type) {

OZ (calc_obj_access_expr(ctx, *expr, *result));

} else {

LOG_DEBUG("spi_calc_expr without row", K(*expr));

bool has_implicit_savepoint = false;

bool explicit_trans = ctx->exec_ctx_->get_my_session()->has_explicit_start_trans();

ObPLContext *pl_ctx = ctx->exec_ctx_->get_pl_stack_ctx();

CK (OB_NOT_NULL(pl_ctx));

if (OB_SUCC(ret) && lib::is_mysql_mode() && !pl_ctx->is_function_or_trigger()) {

if (ctx->exec_ctx_->get_my_session()->is_in_transaction()) {

const ObString expr_savepoint_name("PL expr savepoint");

OZ (ObSqlTransControl::create_savepoint(*ctx->exec_ctx_, expr_savepoint_name));

OX (has_implicit_savepoint = true);

}

}

OZ (ObSQLUtils::calc_sql_expression_without_row(*ctx->exec_ctx_, *expr, *result, ctx->allocator_),

KPC(expr), K(result_idx));

OX(result->set_param_meta());

if ((OB_DATA_OUT_OF_RANGE == ret || OB_ERR_DATA_TOO_LONG == ret

|| OB_ERR_VALUE_LARGER_THAN_ALLOWED == ret) && lib::is_oracle_mode()) {

LOG_WARN("change error code to value error", K(ret));

ret = OB_ERR_NUMERIC_OR_VALUE_ERROR;

}

/* 如果本层是udf, 本次计算的表达式中含有udf;

如果内层udf失败，由udf内部来回滚, 如果内层udf成功, 发生了强转失败等问题, 此处不回滚,

由本层udf的destory接口来保证回滚, 兼容mysql */

if (lib::is_mysql_mode() && !pl_ctx->is_function_or_trigger()) {

if (OB_SUCCESS != ret && ctx->exec_ctx_->get_my_session()->is_in_transaction()) {

int tmp_ret = OB_SUCCESS;

if (has_implicit_savepoint) {

const ObString expr_savepoint_name("PL expr savepoint");

if (OB_SUCCESS !=

(tmp_ret = ObSqlTransControl::rollback_savepoint(*ctx->exec_ctx_, expr_savepoint_name))) {

LOG_WARN("failed to rollback current pl to implicit savepoint", K(ret), K(tmp_ret));

}

#ifdef OB_BUILD_ORACLE_PL

} else if (ctx->exec_ctx_->get_my_session()->associated_xa()) {

if (OB_TRANS_XA_BRANCH_FAIL != ret) {

tmp_ret = ObDbmsXA::xa_rollback_savepoint(*ctx->exec_ctx_);

if (OB_SUCCESS != tmp_ret) {

LOG_WARN("xa trans roll back to save point failed",

K(tmp_ret), KPC(ctx->exec_ctx_->get_my_session()->get_tx_desc()));

}

}

#endif

} else if (ctx->exec_ctx_->get_my_session()->get_in_transaction()) {

tmp_ret = ObPLContext::implicit_end_trans(*ctx->exec_ctx_->get_my_session(), *ctx->exec_ctx_, true);

}

ret = OB_SUCCESS == ret ? tmp_ret : ret;

} else if (ctx->exec_ctx_->get_my_session()->get_local_autocommit() && !explicit_trans) {

if (!ctx->exec_ctx_->get_my_session()->associated_xa()) {

int tmp_ret = OB_SUCCESS;

if (OB_SUCCESS == ret) {

if (OB_SUCCESS != (tmp_ret = ObPLContext::implicit_end_trans(*ctx->exec_ctx_->get_my_session(), *ctx->exec_ctx_, false, true))) {

// 不覆盖原来的错误码

LOG_WARN("failed to explicit end trans", K(ret), K(tmp_ret));

}

}

ret = OB_SUCCESS == ret ? tmp_ret : ret;

}

}

}

}

}

if (OB_SUCC(ret)

&& result->is_binary()

&& result->get_val_len() < result->get_accuracy().get_length()) {

OZ (spi_pad_binary(ctx->exec_ctx_->get_my_session(),

result->get_accuracy(), ctx->allocator_, result));

}

if (OB_SUCC(ret)

&& result->is_character_type()) {

ObObjType type = result->get_type();

if (lib::is_mysql_mode() && T_QUESTIONMARK == get_expression_type(*expr) &&

(ObCharType == type || ObNCharType == type)) {

if (is_pad_char_to_full_length(ctx->exec_ctx_->get_my_session()->get_sql_mode())) {

OZ (spi_pad_char_or_varchar(

ctx->exec_ctx_->get_my_session(), type, result->get_accuracy(), ctx->allocator_, result));

} else {

ObString res = result->get_string();

OZ (ObCharsetUtils::remove_char_endspace( // this function only adjust res.data_length_

res, ObCharset::charset_type_by_coll(result->get_collation_type())));

OX (result->val_len_ = res.length());

}

} else {

OZ (spi_pad_char_or_varchar(

ctx->exec_ctx_->get_my_session(), expr, ctx->allocator_, result));

}

}

if (OB_SUCC(ret)) {

if (result->is_null()) {

result->v_.int64_ = 0;

}

if (OB_INVALID_INDEX != result_idx) {

ObObjParam &param = ctx->params_->at(result_idx);

bool is_ref_cursor = param.is_ref_cursor_type();

ObAccuracy invalid_accuracy;

if (!result->is_ext()) {

bool has_lob_header = result->ObObj::has_lob_header();

if (param.get_meta().get_scale() != SCALE_UNKNOWN_YET) {

result->ObObj::set_scale(param.get_meta().get_scale());

result->set_accuracy(ctx->params_->at(result_idx).get_accuracy());

} else if (result->get_accuracy() == invalid_accuracy) {

result->set_accuracy(ctx->params_->at(result_idx).get_accuracy());

}

if (has_lob_header) {

result->ObObj::set_has_lob_header();

}

param = *result;

param.set_is_ref_cursor_type(is_ref_cursor);

param.set_param_meta();

} else if (!is_ref_cursor) {

int64_t orig_udt_id = ctx->params_->at(result_idx).get_udt_id();

ctx->params_->at(result_idx) = *result;

ctx->params_->at(result_idx).set_udt_id(orig_udt_id);

ctx->params_->at(result_idx).set_param_meta();

}

}

result->set_param_meta();

}

if (OB_SUCC(ret)) {

result->set_is_pl_mock_default_param(expr->get_is_pl_mock_default_expr());

} else if (lib::is_mysql_mode()) {

ctx->exec_ctx_->get_my_session()->set_show_warnings_buf(ret);

}

SET_SPI_STATUS;

return ret;

}

int ObSPIService::spi_calc_subprogram_expr(ObPLExecCtx *ctx,

uint64_t package_id,

uint64_t routine_id,

int64_t expr_idx,

ObObjParam *result)

{

int ret = OB_SUCCESS;

ObExecContext *exec_ctx = NULL;

ObSQLSessionInfo *session_info = NULL;

ObPLExecState *state = NULL;

ObSqlExpression *expr = NULL;

CK (OB_NOT_NULL(exec_ctx = ctx->exec_ctx_));

CK (OB_NOT_NULL(session_info = exec_ctx->get_my_session()));

OZ (ObPLContext::get_exec_state_from_local(*session_info, package_id, routine_id, state));

CK (OB_NOT_NULL(state));

CK (OB_NOT_NULL(exec_ctx = state->get_exec_ctx().exec_ctx_));

CK (expr_idx >= 0 && expr_idx < state->get_function().get_expressions().count());

CK (OB_NOT_NULL(expr = state->get_function().get_expressions().at(expr_idx)));

if (OB_SUCC(ret)) {

ExecCtxBak exec_ctx_bak;

OX (exec_ctx_bak.backup(*exec_ctx));

OX (exec_ctx->set_physical_plan_ctx(&(state->get_physical_plan_ctx())));

if (OB_SUCC(ret) && state->get_function().get_expr_op_size() > 0) {

OZ (exec_ctx->init_expr_op(state->get_function().get_expr_op_size()));

}

OZ (state->get_function().get_frame_info().pre_alloc_exec_memory(*exec_ctx));

OZ (spi_calc_expr(&(state->get_exec_ctx()), expr, OB_INVALID_ID, result), KPC(expr));

if (state->get_function().get_expr_op_size() > 0) {

exec_ctx->reset_expr_op();

exec_ctx->get_allocator().free(exec_ctx->get_expr_op_ctx_store());

}

exec_ctx_bak.restore(*exec_ctx);

}

return ret;

}

int ObSPIService::spi_calc_package_expr_v1(const pl::ObPLResolveCtx &resolve_ctx,

sql::ObExecContext &exec_ctx,

ObIAllocator &allocator,

uint64_t package_id,

int64_t expr_idx,

ObObjParam *result)

{

int ret = OB_SUCCESS;

ObSqlExpression *sql_expr = NULL;