/**

* 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/expr/ob_raw_expr.h"

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

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

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

#include "sql/rewrite/ob_transform_utils.h"

#include "sql/optimizer/ob_logical_operator.h"

#include "common/object/ob_object.h"

#include "common/ob_smart_call.h"

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

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

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

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

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

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

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

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

#include "share/config/ob_server_config.h"

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

using namespace oceanbase::sql;

using namespace oceanbase::common;

using namespace oceanbase::jit::expr;

namespace oceanbase

{

namespace sql

{

ObRawExpr *USELESS_POINTER = NULL;

#define GENERATE_CASE(type, class) \

case type: { \

class *dst = NULL; \

if (OB_FAIL(create_raw_expr_inner(type, dst))) { \

SQL_RESV_LOG(WARN, "failed to create raw expr", K(ret), K(type)); \

} else { \

raw_expr = dst; \

} \

} break;

#define GENERATE_DEFAULT() \

default: { \

if (OB_FAIL(create_raw_expr_inner(expr_type, raw_expr))) { \

SQL_RESV_LOG(WARN, "failed to create raw expr", K(ret), K(expr_type)); \

} \

}

template <>

int ObRawExprFactory::create_raw_expr<ObSysFunRawExpr>(ObItemType expr_type, ObSysFunRawExpr *&raw_expr)

{

int ret = OB_SUCCESS;

switch (expr_type) {

GENERATE_CASE(T_FUN_SYS_SEQ_NEXTVAL, ObSequenceRawExpr);

GENERATE_CASE(T_FUN_NORMAL_UDF, ObNormalDllUdfRawExpr);

GENERATE_CASE(T_FUN_PL_COLLECTION_CONSTRUCT, ObCollectionConstructRawExpr);

GENERATE_CASE(T_FUN_UDF, ObUDFRawExpr);

GENERATE_CASE(T_FUN_PL_OBJECT_CONSTRUCT, ObObjectConstructRawExpr);

GENERATE_CASE(T_FUN_PL_GET_CURSOR_ATTR, ObPLGetCursorAttrRawExpr);

GENERATE_CASE(T_FUN_PL_SQLCODE_SQLERRM, ObPLSQLCodeSQLErrmRawExpr);

GENERATE_DEFAULT();

}

return ret;

}

template<>

int ObRawExprFactory::create_raw_expr<ObOpRawExpr>(ObItemType expr_type, ObOpRawExpr *&raw_expr)

{

int ret = OB_SUCCESS;

switch (expr_type) {

GENERATE_CASE(T_FUN_PL_INTEGER_CHECKER, ObPLIntegerCheckerRawExpr);

GENERATE_CASE(T_SP_CPARAM, ObCallParamRawExpr);

GENERATE_CASE(T_FUN_PL_ASSOCIATIVE_INDEX, ObPLAssocIndexRawExpr);

GENERATE_CASE(T_OBJ_ACCESS_REF, ObObjAccessRawExpr);

GENERATE_CASE(T_OP_MULTISET, ObMultiSetRawExpr);

GENERATE_CASE(T_OP_COLL_PRED, ObCollPredRawExpr);

GENERATE_DEFAULT();

}

return ret;

}

#undef GENERATE_CASE

#undef GENERATE_DEFAULT

void ObQualifiedName::format_qualified_name(ObNameCaseMode mode)

{

UNUSED(mode); //TODO: @ryan.ly @yuming.wyc

bool maybe_column = !is_sys_func() && !is_pl_udf() && !is_dll_udf() && !is_pl_var() && !is_udf_return_access();

for (int64_t i = 0; maybe_column && i < access_idents_.count(); ++i) {

if (access_idents_.at(i).access_name_.empty() || access_idents_.at(i).access_index_ != OB_INVALID_INDEX) {

maybe_column = false;

}

}

if (maybe_column && access_idents_.count() == 1) {

col_name_ = access_idents_.at(0).access_name_;

}

if (maybe_column && access_idents_.count() == 2) {

tbl_name_ = access_idents_.at(0).access_name_;

col_name_ = access_idents_.at(1).access_name_;

}

if (maybe_column && access_idents_.count() == 3) {

database_name_ = access_idents_.at(0).access_name_;

tbl_name_ = access_idents_.at(1).access_name_;

col_name_ = access_idents_.at(2).access_name_;

}

}

int ObQualifiedName::replace_access_ident_params(ObRawExpr *from, ObRawExpr *to)

{

int ret = common::OB_SUCCESS;

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

OZ (access_idents_.at(i).replace_params(from, to));

}

return ret;

}

int ObObjAccessIdent::extract_params(int64_t level, common::ObIArray<ObRawExpr*> &params) const

{

int ret = common::OB_SUCCESS;

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

if (params_.at(i).second == level && OB_FAIL(params.push_back(params_.at(i).first))) {

LOG_WARN("push back error", K(ret));

}

}

return ret;

}

int ObObjAccessIdent::replace_params(ObRawExpr *from, ObRawExpr *to)

{

int ret = common::OB_SUCCESS;

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

OZ (ObRawExprUtils::replace_ref_column(params_.at(i).first, from, to));

}

return ret;

}

int OrderItem::deep_copy(ObIRawExprCopier &copier,

const OrderItem &other)

{

int ret = common::OB_SUCCESS;

order_type_ = other.order_type_;

expr_ = other.expr_;

if (OB_FAIL(copier.copy(expr_))) {

LOG_WARN("failed to copy expr when copying OrderItem", K(ret));

}

return ret;

}

OB_SERIALIZE_MEMBER(ObVarInfo, type_, name_);

int ObVarInfo::deep_copy(common::ObIAllocator &allocator, ObVarInfo &var_info) const

{

int ret = OB_SUCCESS;

ObString clone_name;

if (OB_FAIL(ob_write_string(allocator, name_, clone_name))) {

LOG_WARN("fail to write string", K(name_), K(*this), K(ret));

} else {

var_info.type_ = type_;

var_info.name_ = clone_name;

}

return ret;

}

ObRawExpr::~ObRawExpr()

{

if (0x86427531 == magic_num_) {

LOG_ERROR_RET(OB_ERROR, "ObRawExpr maybe double free!");

}

magic_num_ = 0x86427531;

}

//这个函数用来判断这个表达式本身或者参数是否含有非常量表达式

//常量表达式的定义是在plan中需要特定的operator产生的表达式

//我们约定ObBinaryRefExpr必须由TableScan产生

//ObAggFunRawExpr必须由Groupby operator产生

//ObSetOpRawExpr必须由Set operator产生

//ObUnaryRefExpr(即subquery ref)必须由SubPlanFilter产生

//PSEUDO_COLUMN一般是由CTE或者层次查询产生

//SYS_CONNECT_BY_PATH,CONNECT_BY_ROOT由cby nestloop join产生

bool ObRawExpr::has_generalized_column() const

{

return has_flag(CNT_COLUMN) || has_flag(CNT_AGG) || has_flag(CNT_SET_OP) || has_flag(CNT_SUB_QUERY)

|| has_flag(CNT_WINDOW_FUNC) || has_flag(CNT_ROWNUM) || has_flag(CNT_PSEUDO_COLUMN)

|| has_flag(CNT_SEQ_EXPR) || has_flag(CNT_SYS_CONNECT_BY_PATH) || has_flag(CNT_CONNECT_BY_ROOT)

|| has_flag(CNT_OP_PSEUDO_COLUMN);

}

//这个函数是用来判断表达式中是否可能存在enum或者set的列

bool ObRawExpr::has_enum_set_column() const

{

return has_flag(CNT_ENUM_OR_SET);

}

bool ObRawExpr::has_specified_pseudocolumn() const

{

return has_flag(CNT_ROWNUM) || has_flag(CNT_PSEUDO_COLUMN);

}

bool ObRawExpr::is_vectorize_result() const

{

// subset of ObRawExpr::cnt_not_calculable_expr

// TODO bin.lb: more sophisticate

bool not_pre_calc = has_generalized_column()

|| has_flag(CNT_STATE_FUNC)

|| has_flag(CNT_DYNAMIC_USER_VARIABLE)

|| has_flag(CNT_ALIAS)

|| has_flag(CNT_VALUES)

|| has_flag(CNT_SEQ_EXPR)

|| has_flag(CNT_SYS_CONNECT_BY_PATH)

|| has_flag(CNT_RAND_FUNC)

|| has_flag(CNT_SO_UDF)

|| has_flag(CNT_PRIOR)

|| has_flag(CNT_OP_PSEUDO_COLUMN)

|| has_flag(CNT_VOLATILE_CONST);

// Cant be const expr, const expr's evaluate flag is not cleared in execution.

// E.g.:

// last_insert_id() is not pre-calculable but is const set to vectorize result will

// coredump because evaluate flag not cleared which reset datum's pointers depends.

bool is_const = is_const_expr();

return not_pre_calc && !is_const;

}

int ObRawExpr::assign(const ObRawExpr &other)

{

int ret = OB_SUCCESS;

if (OB_LIKELY(&other != this)) {

if (OB_UNLIKELY(get_expr_type() != other.get_expr_type()) ||

OB_UNLIKELY(get_expr_class() != other.get_expr_class())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("expr type or class does not match", K(ret),

K(get_expr_type()), K(other.get_expr_type()),

K(get_expr_class()), K(other.get_expr_class()));

} else {

result_type_ = other.result_type_;

info_ = other.info_;

rel_ids_ = other.rel_ids_;

alias_column_name_ = other.alias_column_name_;

expr_name_= other.expr_name_;

ref_count_ = other.ref_count_;

reference_type_ = other.reference_type_;

is_for_generated_column_ = other.is_for_generated_column_;

extra_ = other.extra_;

is_called_in_sql_ = other.is_called_in_sql_;

is_calculated_ = other.is_calculated_;

is_deterministic_ = other.is_deterministic_;

partition_id_calc_type_ = other.partition_id_calc_type_;

if (OB_FAIL(enum_set_values_.assign(other.enum_set_values_))) {

LOG_WARN("failed to assign enum set values", K(ret));

} else { /*do nothing*/ }

}

}

return ret;

}

int ObRawExpr::deep_copy(ObIRawExprCopier &copier,

const ObRawExpr &other)

{

int ret = OB_SUCCESS;

if (OB_LIKELY(&other != this)) {

if (OB_FAIL(assign(other))) {

LOG_WARN("failed to assign other expr", K(ret));

} else if (OB_FAIL(inner_deep_copy(copier))) {

LOG_WARN("failed to deep copy new allocator", K(ret));

}

}

return ret;

}

int ObRawExpr::inner_deep_copy(ObIRawExprCopier &copier)

{

int ret = OB_SUCCESS;

if (copier.deep_copy_attributes()) {

ObObj param;

if (OB_ISNULL(inner_alloc_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("inner allocator or expr factory is NULL", K(inner_alloc_), K(ret));

} else if (OB_FAIL(ob_write_string(*inner_alloc_,

alias_column_name_,

alias_column_name_))) {

LOG_WARN("fail to write string", K(alias_column_name_), K(ret));

} else if (OB_FAIL(ob_write_string(*inner_alloc_, expr_name_, expr_name_))) {

LOG_WARN("fail to write string", K(expr_name_), K(ret));

} else if (OB_FAIL(deep_copy_obj(*inner_alloc_, result_type_.get_param(), param))) {

LOG_WARN("failed to deep copy object", K(ret), K(param));

} else {

result_type_.set_param(param);

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

if (OB_FAIL(ob_write_string(*inner_alloc_, enum_set_values_.at(i), enum_set_values_.at(i)))) {

LOG_WARN("fail to write string", K(ret), K(enum_set_values_), K(i));

}

}

}

}

return ret;

}

int ObRawExpr::replace_expr(const ObIArray<ObRawExpr *> &other_exprs,

const ObIArray<ObRawExpr *> &new_exprs)

{

int ret = OB_SUCCESS;

UNUSED(other_exprs);

UNUSED(new_exprs);

return ret;

}

void ObRawExpr::reset()

{

type_ = T_INVALID;

info_.reset();

rel_ids_.reset();

set_data_type(ObMaxType);

ref_count_ = 0;

reference_type_ = ExplicitedRefType::NONE_REF;

is_for_generated_column_ = false;

is_called_in_sql_ = true;

is_calculated_ = false;

is_deterministic_ = true;

}

int ObRawExpr::get_name(char *buf, const int64_t buf_len, int64_t &pos, ExplainType type) const

{

int ret = OB_SUCCESS;

bool is_stack_overflow = false;

if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {

LOG_WARN("fail to check stack overflow", K(ret), K(is_stack_overflow));

} else if (is_stack_overflow) {

LOG_DEBUG("too deep recursive", K(ret), K(is_stack_overflow));

} else {

if (OB_FAIL(get_name_internal(buf, buf_len, pos, type))) {

LOG_WARN("fail to get_name", K(buf_len), K(pos), K(ret));

}

}

return ret;

}

int ObRawExpr::get_type_and_length(char *buf, const int64_t buf_len, int64_t &pos, ExplainType type) const

{

int ret = OB_SUCCESS;

if (EXPLAIN_EXTENDED == type || EXPLAIN_EXTENDED_NOADDR == type) {

const char* type_str = common::inner_obj_type_str(get_data_type());

if (nullptr == type_str || strlen(type_str) > INT32_MAX) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("some error happend");

} else {

int str_length = (int)strlen(type_str);

int32_t out_data = get_accuracy().get_precision();

bool output_length = ob_is_accuracy_length_valid_tc(get_data_type());

if (output_length) {

out_data = get_accuracy().get_length();

}

if (OB_FAIL(BUF_PRINTF(", %.*s, %d", str_length, type_str, out_data))) {

LOG_WARN("fail to BUF_PRINTF", K(ret));

}else { }

}

} else {

//do nothing

}

return ret;

}

int ObRawExpr::extract_info()

{

//LOG_DEBUG("extract_info", "usec", ObSQLUtils::get_usec());

//scope may be NULL, do not check

int ret = OB_SUCCESS;

ObRawExprInfoExtractor extractor;

if (OB_FAIL(extractor.analyze(*this))) {

LOG_WARN("fail to analyze", K(ret));

}

//LOG_DEBUG("extractor_info", "usec", ObSQLUtils::get_usec());

return ret;

}

int ObRawExpr::deduce_type(const ObSQLSessionInfo *session_info)

{

//LOG_DEBUG("deduce_type", "usec", ObSQLUtils::get_usec());

int ret = OB_SUCCESS;

ObRawExprDeduceType expr_deducer(session_info);

expr_deducer.set_expr_factory(expr_factory_);

if (OB_FAIL(expr_deducer.deduce(*this))) {

if (session_info->is_varparams_sql_prepare()) {

ret = OB_SUCCESS;

LOG_TRACE("ps prepare phase ignores type deduce error");

} else {

LOG_WARN("fail to deduce", K(ret));

}

}

//LOG_DEBUG("deduce_type", "usec", ObSQLUtils::get_usec());

return ret;

}

int ObRawExpr::formalize(const ObSQLSessionInfo *session_info)

{

int ret = OB_SUCCESS;

bool is_stack_overflow = false;

if (OB_FAIL(check_stack_overflow(is_stack_overflow))) {

LOG_WARN("fail to check stack overflow", K(ret), K(is_stack_overflow));

} else if (is_stack_overflow) {

ret = OB_SIZE_OVERFLOW;

LOG_WARN("too deep recursive", K(ret), K(is_stack_overflow));

} else if (OB_FAIL(extract_info())) {

LOG_WARN("failed to extract info", K(*this));

} else if (OB_FAIL(deduce_type(session_info))) {

LOG_WARN("failed to deduce type", K(*this));

} else {}

return ret;

}

int ObRawExpr::pull_relation_id()

{

int ret = OB_SUCCESS;

ObExprRelationAnalyzer expr_relation_analyzer;

if (OB_FAIL(expr_relation_analyzer.pull_expr_relation_id(this))) {

LOG_WARN("pull expr failed", K(ret));

}

return ret;

}

int ObRawExpr::add_child_flags(const ObExprInfo &flags)

{

int ret = OB_SUCCESS;

if (INHERIT_MASK_BEGIN < flags.bit_count()) {

ObExprInfo tmp(flags);

int64_t mask_end = INHERIT_MASK_END < flags.bit_count() ?

static_cast<int64_t>(INHERIT_MASK_END) : flags.bit_count() - 1;

if (OB_FAIL(tmp.do_mask(INHERIT_MASK_BEGIN, mask_end))) {

LOG_WARN("failed to do mask", K(ret));

} else if (OB_FAIL(info_.add_members(tmp))) {

LOG_WARN("failed to add expr info", K(ret));

}

}

for (int32_t i = 0; OB_SUCC(ret) && i <= IS_INFO_MASK_END; ++i) {

if (flags.has_member(i)) {

if (OB_FAIL(info_.add_member(i + CNT_INFO_MASK_BEGIN))) {

LOG_WARN("failed to add member", K(i), K(ret));

}

}

}

return ret;

}

int ObRawExpr::set_expr_name(const common::ObString &expr_name)

{

int ret = OB_SUCCESS;

if (OB_ISNULL(inner_alloc_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("inner allocator or expr factory is NULL", K(inner_alloc_), K(ret));

} else if (OB_FAIL(ob_write_string(*inner_alloc_, expr_name, expr_name_))) {

LOG_WARN("write string failed", K(ret));

}

return ret;

}

int ObRawExpr::preorder_accept(ObRawExprVisitor &visitor)

{

int ret = OB_SUCCESS;

if (OB_FAIL(do_visit(visitor))) {

LOG_WARN("visit failed", K(ret),

"type", get_expr_type(), "name", get_type_name(get_expr_type()));

} else {

if (!skip_visit_child() && !visitor.skip_child(*this)) {

const int64_t cnt = get_param_count();

for (int64_t i = 0; i < cnt && OB_SUCC(ret); i++) {

ObRawExpr *e = get_param_expr(i);

if (NULL == e) {

LOG_WARN("null param expr returned", K(ret), K(i), K(cnt));

} else if (OB_FAIL(SMART_CALL(e->preorder_accept(visitor)))) {

LOG_WARN("child visit failed", K(ret), K(i),

"type", get_expr_type(), "name", get_type_name(get_expr_type()));

}

}

}

}

return ret;

}

int ObRawExpr::postorder_accept(ObRawExprVisitor &visitor)

{

int ret = OB_SUCCESS;

if (!skip_visit_child() && !visitor.skip_child(*this)) {

const int64_t cnt = get_param_count();

for (int64_t i = 0; i < cnt && OB_SUCC(ret); i++) {

ObRawExpr *e = get_param_expr(i);

if (NULL == e) {

LOG_WARN("null param expr returned", K(ret), K(i), K(cnt));

} else if (OB_FAIL(SMART_CALL(e->postorder_accept(visitor)))) {

LOG_WARN("child visit failed", K(ret), K(i),

"type", get_expr_type(), "name", get_type_name(get_expr_type()));

}

}

}

if (OB_SUCC(ret)) {

if (OB_FAIL(do_visit(visitor))) {

LOG_WARN("visit failed", K(ret),

"type", get_expr_type(), "name", get_type_name(get_expr_type()));

}

}

return ret;

}

// Get identify expr for same as check:

// 1. Original expr of exec param expr

// 2. Skip the inner added implicit cast expr for none root node, e.g.:

// abs(cast(c1)) is same as abs(c1)

// but: cast(abs(c1)) is not same as abs(c1)

const ObRawExpr *ObRawExpr::get_same_identify(const ObRawExpr *e,

const ObExprEqualCheckContext *check_ctx) const

{

while (NULL != e) {

if (e->is_exec_param_expr()) {

if (NULL != static_cast<const ObExecParamRawExpr *>(e)->get_ref_expr()) {

e = static_cast<const ObExecParamRawExpr *>(e)->get_ref_expr();

}

} else if (NULL != check_ctx && check_ctx->ignore_implicit_cast_

&& check_ctx->recursion_level_ > 1

&& T_FUN_SYS_CAST == e->get_expr_type()

&& e->has_flag(IS_OP_OPERAND_IMPLICIT_CAST)) {

e = e->get_param_expr(0);

} else {

break;

}

}

return e;

}

bool ObRawExpr::is_spatial_expr() const

{

const ObRawExpr *expr = ObRawExprUtils::skip_inner_added_expr(this);

return IS_SPATIAL_OP(expr->get_expr_type());

}

bool ObRawExpr::is_geo_expr() const

{

return IS_GEO_OP(get_expr_type());

}

bool ObRawExpr::is_xml_expr() const

{

return IS_XML_OP(get_expr_type());

}

bool ObRawExpr::is_mysql_geo_expr() const

{

return IS_MYSQL_GEO_OP(get_expr_type());

}

bool ObRawExpr::is_priv_geo_expr() const

{

return IS_PRIV_GEO_OP(get_expr_type());

}

ObGeoType ObRawExpr::get_geo_expr_result_type() const

{

if (!is_geo_expr() && T_FUN_SYS_CAST != this->get_expr_type()) {

LOG_WARN_RET(OB_ERR_UNEXPECTED, "Expr is not a geo expr");

return ObGeoType::GEOTYPEMAX;

} else {

switch (this->get_expr_type()) {

case T_FUN_SYS_CAST: {

int ret = OB_SUCCESS;

ObGeoType geo_type = ObGeoType::GEOTYPEMAX;

if (OB_FAIL(get_geo_cast_result_type(geo_type))) {

LOG_WARN("could not get geo type from cast", K(ret));

}

return geo_type;

}

case T_FUN_SYS_POINT:

return ObGeoType::POINT;

case T_FUN_SYS_LINESTRING:

return ObGeoType::LINESTRING;

case T_FUN_SYS_MULTIPOINT:

return ObGeoType::MULTIPOINT;

case T_FUN_SYS_MULTILINESTRING:

return ObGeoType::MULTILINESTRING;

case T_FUN_SYS_POLYGON:

return ObGeoType::POLYGON;

case T_FUN_SYS_MULTIPOLYGON:

return ObGeoType::MULTIPOLYGON;

case T_FUN_SYS_GEOMCOLLECTION:

return ObGeoType::GEOMETRYCOLLECTION;

default:

return ObGeoType::GEOMETRY;

}

}

}

int ObRawExpr::get_geo_cast_result_type(ObGeoType& geo_type) const

{

int ret = OB_SUCCESS;

if (T_FUN_SYS_CAST != get_expr_type()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("should be cast expr", K(ret));

} else if (OB_ISNULL(get_param_expr(1))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("cast second param expr is NULL", K(ret));

} else if (!get_param_expr(1)->is_const_expr()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("cast second param expr is not const expr", K(ret));

} else {

const ObConstRawExpr *const_expr = static_cast<const ObConstRawExpr*>(get_param_expr(1));

ObObj value = const_expr->get_value();

if (!value.is_int()) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("value of second param expr is not int", K(value), K(ret));

} else {

ParseNode parse_node;

parse_node.value_ = value.get_int();

geo_type = static_cast<ObGeoType>(parse_node.int16_values_[OB_NODE_CAST_GEO_TYPE_IDX]);

}

}

return ret;

}

bool ObRawExpr::same_as(const ObRawExpr &expr,

ObExprEqualCheckContext *check_context) const

{

bool bret = false;

if (this == &expr) {

bret = true;

} else {

if (NULL != check_context) {

check_context->recursion_level_ += 1;

}

const ObRawExpr *l = get_same_identify(this, check_context);

const ObRawExpr *r = get_same_identify(&expr, check_context);

bret = l->inner_same_as(*r, check_context);

if (NULL != check_context) {

check_context->recursion_level_ -= 1;

}

}

return bret;

}

////////////////////////////////////////////////////////////////

ObRawExpr *&ObTerminalRawExpr::get_param_expr(int64_t index)

{

UNUSED(index);

return USELESS_POINTER;

}

bool ObRawExpr::is_bool_expr() const

{

return IS_BOOL_OP(type_) || (is_const_raw_expr() && static_cast<const ObConstRawExpr*>(this)->is_literal_bool());

}

bool ObRawExpr::is_json_expr() const

{

return (T_FUN_SYS_JSON_OBJECT <= get_expr_type() && get_expr_type() <= T_FUN_JSON_OBJECTAGG) ? true : false;

}

bool ObRawExpr::is_multiset_expr() const

{

return is_query_ref_expr() && static_cast<const ObQueryRefRawExpr *>(this)->is_multiset();

}

int ObRawExpr::set_enum_set_values(const common::ObIArray<common::ObString> &values)

{

int ret = OB_SUCCESS;

if (OB_FAIL(enum_set_values_.assign(values))) {

LOG_WARN("failed to assign array", K(ret));

}

return ret;

}

bool ObRawExpr::is_not_calculable_expr() const

{

return is_generalized_column()

|| has_flag(IS_STATE_FUNC)

|| has_flag(IS_DYNAMIC_USER_VARIABLE)

|| has_flag(IS_ALIAS)

|| has_flag(IS_VALUES)

|| has_flag(IS_SEQ_EXPR)

|| has_flag(IS_SYS_CONNECT_BY_PATH)

|| has_flag(IS_RAND_FUNC)

|| has_flag(IS_SO_UDF_EXPR)

|| has_flag(IS_PRIOR)

|| has_flag(IS_VOLATILE_CONST)

|| has_flag(IS_ASSIGN_EXPR);

}

bool ObRawExpr::cnt_not_calculable_expr() const

{

// NOTE: When adding rules here, please check whether ObRawExpr::is_vectorize_result()

// need add the same rules.

return has_generalized_column()

|| has_flag(CNT_STATE_FUNC)

|| has_flag(CNT_DYNAMIC_USER_VARIABLE)

|| has_flag(CNT_ALIAS)

|| has_flag(CNT_VALUES)

|| has_flag(CNT_SEQ_EXPR)

|| has_flag(CNT_SYS_CONNECT_BY_PATH)

|| has_flag(CNT_RAND_FUNC)

|| has_flag(CNT_SO_UDF)

|| has_flag(CNT_PRIOR)

|| has_flag(CNT_VOLATILE_CONST)

|| has_flag(CNT_ASSIGN_EXPR);

}

/**

* @brief check whether an expr is const when all of its param exprs are const expr.

* param_need_replace is true when called in ObOptimizerUtil::is_const_expr_recursively

* e.g.:

* 1 + exists (select 1 > t1) will be const expr after replacing the T_OP_EXISTS with onetime expr,

* we need to treat the expr as const expr without replacement when generate logical plan.

* The param_need_replace flag only disables the shortcut of cnt_not_calculable_expr(),

* the param expr remains non-const if it can not be replaced into exec param

*/

int ObRawExpr::is_const_inherit_expr(bool &is_const_inherit,

const bool param_need_replace /*=false*/) const

{

int ret = OB_SUCCESS;

is_const_inherit = true;

if (T_FUN_SYS_RAND == type_

|| T_FUN_SYS_RANDOM == type_

|| T_FUN_SYS_GENERATOR == type_

|| T_FUN_SYS_UUID == type_

|| T_FUN_SYS_UUID_SHORT == type_

|| T_FUN_SYS_SEQ_NEXTVAL == type_

|| T_FUN_SYS_AUTOINC_NEXTVAL == type_

|| T_FUN_SYS_TABLET_AUTOINC_NEXTVAL == type_

|| T_FUN_SYS_ROWNUM == type_

|| T_FUN_SYS_ROWKEY_TO_ROWID == type_

|| T_OP_CONNECT_BY_ROOT == type_

|| T_FUN_SYS_CONNECT_BY_PATH == type_

|| T_FUN_SYS_GUID == type_

|| T_FUN_SYS_STMT_ID == type_

|| T_FUN_SYS_SLEEP == type_

|| T_OP_PRIOR == type_

|| T_OP_ASSIGN == type_

|| T_FUN_NORMAL_UDF == type_

|| T_FUN_SYS_REMOVE_CONST == type_

|| T_FUN_SYS_WRAPPER_INNER == type_

|| (T_FUN_SYS_LAST_INSERT_ID == type_ && get_param_count() > 0)

|| T_FUN_SYS_TO_BLOB == type_

|| (T_FUN_SYS_SYSDATE == type_ && lib::is_mysql_mode())

|| (param_need_replace ? is_not_calculable_expr() : cnt_not_calculable_expr())

|| (T_FUN_UDF == type_

&& !static_cast<const ObUDFRawExpr*>(this)->is_deterministic())) {

is_const_inherit = false;

}

if (is_const_inherit && T_OP_GET_USER_VAR == type_) {

if (get_param_count() != 1 || OB_ISNULL(get_param_expr(0)) ||

get_param_expr(0)->type_ != T_USER_VARIABLE_IDENTIFIER) {

ret = OB_ERR_UNEXPECTED;

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

} else {

const ObUserVarIdentRawExpr *var_expr =

static_cast<const ObUserVarIdentRawExpr*>(get_param_expr(0));

if (var_expr->get_is_contain_assign() || var_expr->get_query_has_udf()) {

is_const_inherit = false;

}

}

}

return ret;

}

/**

* @brief 判断Oracle的系统函数是不是pure的，用于创建生成列或函数索引时的检查

* @return

*/

int ObRawExpr::is_non_pure_sys_func_expr(bool &is_non_pure) const

{

int ret = OB_SUCCESS;

is_non_pure = false;

if (lib::is_oracle_mode()) {

if (T_FUN_SYS_LOCALTIMESTAMP == type_

|| T_FUN_SYS_SESSIONTIMEZONE == type_

|| T_FUN_SYS_DBTIMEZONE == type_

|| T_FUN_SYS_SYSDATE == type_

|| T_FUN_SYS_SYSTIMESTAMP == type_

|| T_FUN_SYS_UID == type_

|| T_FUN_SYS_USER == type_

|| T_FUN_SYS_CUR_TIMESTAMP == type_

|| T_FUN_SYS_RANDOM == type_

|| T_FUN_SYS_GUID == type_

|| T_FUN_SYS_CUR_DATE == type_

|| T_FUN_SYS_USERENV == type_

|| T_FUN_SYS_REGEXP_REPLACE == type_

|| T_FUN_GET_TEMP_TABLE_SESSID == type_

|| T_FUN_SYS_USER_CAN_ACCESS_OBJ == type_) {

is_non_pure = true;

} else if (T_FUN_SYS_TO_DATE == type_ || T_FUN_SYS_TO_TIMESTAMP == type_ ||

T_FUN_SYS_TO_TIMESTAMP_TZ == type_) {

const ObRawExpr *format_expr = NULL;

if (get_param_count() < 2) {

is_non_pure = true;

} else if (OB_ISNULL(format_expr = get_param_expr(1))) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("param expr is null", K(ret));

} else if (!format_expr->is_const_raw_expr()) {

is_non_pure = true;

} else {

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

const ObObj &value = const_expr->get_value();

bool need_tz = T_FUN_SYS_TO_TIMESTAMP_TZ == type_;

bool complete = true;

if (OB_UNLIKELY(!value.is_string_type())) {

// just pass, will report error when calc result type

if (value.is_null()) {

is_non_pure = true;

}

} else if (OB_FAIL(ObTimeConverter::check_dfm_deterministic(value.get_string(),

value.get_collation_type(),

need_tz, complete))) {

LOG_WARN("check datetime format model complete failed", K(ret), K(value));

} else {

is_non_pure = !complete;

}

}

}

} else {

if (T_FUN_SYS_CONNECTION_ID == type_

|| T_FUN_SYS_VERSION == type_

|| T_FUN_SYS_CURRENT_USER == type_

|| T_FUN_SYS_USER == type_

|| T_FUN_SYS_DATABASE == type_

|| T_FUN_SYS_SYSDATE == type_

|| T_FUN_SYS_CUR_DATE == type_

|| T_FUN_SYS_CUR_TIME == type_

|| T_FUN_SYS_CUR_TIMESTAMP == type_

|| T_FUN_SYS_UNIX_TIMESTAMP == type_

|| T_FUN_SYS_UTC_TIME == type_

|| T_FUN_SYS_UTC_TIMESTAMP == type_

|| T_FUN_SYS_UTC_DATE == type_

|| T_FUN_SYS_RAND == type_

|| T_FUN_SYS_RANDOM == type_

|| T_FUN_SYS_UUID == type_

|| T_FUN_SYS_UUID_SHORT == type_

|| T_FUN_SYS_SLEEP == type_

|| T_FUN_SYS_LAST_INSERT_ID == type_

|| T_FUN_SYS_ROW_COUNT == type_

|| T_FUN_SYS_FOUND_ROWS == type_

|| T_FUN_SYS_CURRENT_USER_PRIV == type_) {

is_non_pure = true;

}

}

return ret;

}

/**

* @brief 判断Oracle的伪列能否出现在生成列中

* @return

*/

bool ObRawExpr::is_specified_pseudocolumn_expr() const

{

if (T_FUN_SYS_ROWNUM == type_

|| T_LEVEL == type_

|| T_CONNECT_BY_ISCYCLE == type_

|| T_CONNECT_BY_ISLEAF == type_) {

return true;

}

return false;

}

////////////////////////////////////////////////////////////////

int ObConstRawExpr::assign(const ObRawExpr &other)

{

int ret = OB_SUCCESS;

if (OB_LIKELY(this != &other)) {

if (OB_UNLIKELY(get_expr_class() != other.get_expr_class() ||

get_expr_type() != other.get_expr_type())) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("invalid input expr", K(ret), K(other.get_expr_type()));

} else if (OB_FAIL(ObTerminalRawExpr::assign(other))) {

LOG_WARN("copy in Base class ObTerminalRawExpr failed", K(ret));

} else {

const ObConstRawExpr &const_expr = static_cast<const ObConstRawExpr &>(other);

value_ = const_expr.get_value();

literal_prefix_ = const_expr.get_literal_prefix();

obj_meta_ = const_expr.get_expr_obj_meta();

is_date_unit_ = const_expr.is_date_unit_;

is_literal_bool_ = const_expr.is_literal_bool();

array_param_group_id_ = const_expr.get_array_param_group_id();

is_dynamic_eval_questionmark_ = const_expr.is_dynamic_eval_questionmark_;

orig_questionmark_type_.assign(const_expr.get_orig_qm_type());

}

}

return ret;

}

int ObConstRawExpr::inner_deep_copy(ObIRawExprCopier &copier)

{

int ret = OB_SUCCESS;

if (OB_FAIL(ObTerminalRawExpr::inner_deep_copy(copier))) {

LOG_WARN("copy in Base class ObTerminalRawExpr failed", K(ret));

} else if (copier.deep_copy_attributes()) {

ObObj tmp;

if (OB_ISNULL(inner_alloc_)) {

ret = OB_ERR_UNEXPECTED;

LOG_WARN("inner allocator is NULL", K(ret));

} else if (OB_FAIL(deep_copy_obj(*inner_alloc_, value_, tmp))) {

LOG_WARN("deep copy error", K(value_), K(ret));

} else if (OB_FAIL(ob_write_string(*inner_alloc_, literal_prefix_, literal_prefix_))) {

LOG_WARN("failed to write string", K(ret));

} else {

value_ = tmp;

}

}

return ret;

}

int ObConstRawExpr::replace_expr(const ObIArray<ObRawExpr *> &other_exprs,

const ObIArray<ObRawExpr *> &new_exprs)

{

int ret = OB_SUCCESS;

if (OB_FAIL(ObTerminalRawExpr::replace_expr(other_exprs, new_exprs))) {

LOG_WARN("failed to replace expr", K(ret));

} else { /*do nothing*/ }

return ret;

}

void ObConstRawExpr::set_value(const ObObj &val)

{

set_meta_type(val.get_meta()); //让const raw expr的类型和值类型相同

set_expr_obj_meta(val.get_meta());

value_ = val;

}

void ObConstRawExpr::set_literal_prefix(const ObString &name)

{

literal_prefix_ = name;

}

void ObConstRawExpr::reset()

{

ObRawExpr::reset();

value_.reset();

literal_prefix_.reset();

is_literal_bool_ = false;

array_param_group_id_ = -1;

is_dynamic_eval_questionmark_ = false;

orig_questionmark_type_.reset();

}

void ObConstRawExpr::set_is_date_unit()

{

is_date_unit_ = true;

}

void ObConstRawExpr::reset_is_date_unit()

{

is_date_unit_ = false;

}

uint64_t ObConstRawExpr::hash_internal(uint64_t seed) const

{

uint64_t hash_val = seed;

value_.hash(hash_val, seed);

if (T_QUESTIONMARK == get_expr_type() && is_dynamic_eval_questionmark()) {

if (!(result_type_.is_decimal_int() || result_type_.is_number())

|| !(orig_questionmark_type_.is_decimal_int() || orig_questionmark_type_.is_number())) {

int ret = OB_NOT_SUPPORTED;

LOG_WARN("not supported dynamic eval quesiton mark", K(ret));

OB_ASSERT(false);

// do nothing

} else {

// if questionmark is evaluated during runtime, it's value is determined by:

// - value_

// - result_type_

// - result_type_'s cast_mode

ObCastMode cm = result_type_.get_cast_mode();

hash_val = ObMurmurHash::hash(&cm, sizeof(uint64_t), hash_val);

if (result_type_.is_decimal_int()) {

// value determined by precision & scale

ObPrecision prec = result_type_.get_precision();

ObScale scale = result_type_.get_scale();

hash_val = ObMurmurHash::hash(&prec, sizeof(ObPrecision), hash_val);

hash_val = ObMurmurHash::hash(&scale, sizeof(ObScale), hash_val);

} else if (result_type_.is_number()) {

// decint->number, precision & scale are both ignored

// do nothing

}

}

}

return hash_val;

}

bool ObConstRawExpr::inner_same_as(

const ObRawExpr &expr,

ObExprEqualCheckContext *check_context) const

{

bool bool_ret = false;

if ((T_QUESTIONMARK == get_expr_type() && is_dynamic_eval_questionmark())