308 lines
9.5 KiB
C++
308 lines
9.5 KiB
C++
/**
|
|
* 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_ENG
|
|
|
|
#include "sql/engine/expr/ob_expr_truncate.h"
|
|
#include "sql/engine/expr/ob_expr_util.h"
|
|
#include "objit/common/ob_item_type.h"
|
|
#include "share/object/ob_obj_cast.h"
|
|
#include "sql/session/ob_sql_session_info.h"
|
|
|
|
#define GET_SCALE_FOR_CALC(scale) (scale < 0 ? max((-1) * OB_MAX_DECIMAL_PRECISION, scale) : \
|
|
min(OB_MAX_DECIMAL_SCALE, scale))
|
|
|
|
#define GET_SCALE_FOR_CALC_ORACLE(scale) (scale < 0 ? max((-1) * OB_MAX_NUMBER_PRECISION, scale) : \
|
|
min(OB_MAX_NUMBER_SCALE, scale))
|
|
|
|
#define GET_SCALE_FOR_DEDUCE(scale) (scale < 0 ? 0 : min(OB_MAX_DECIMAL_SCALE, scale))
|
|
#define GET_SCALE_FOR_DEDUCE_ORACLE(scale) (scale < 0 ? 0 : min(OB_MAX_NUMBER_SCALE, scale))
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace sql
|
|
{
|
|
using namespace common;
|
|
|
|
ObExprTruncate::ObExprTruncate(common::ObIAllocator &alloc)
|
|
: ObFuncExprOperator(alloc,
|
|
T_FUN_SYS_TRUNCATE,
|
|
N_TRUNCATE,
|
|
2,
|
|
NOT_ROW_DIMENSION) {}
|
|
|
|
int ObExprTruncate::calc_result_type2(ObExprResType &type,
|
|
ObExprResType &type1,
|
|
ObExprResType &type2,
|
|
common::ObExprTypeCtx &type_ctx) const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const ObSQLSessionInfo *session =
|
|
dynamic_cast<const ObSQLSessionInfo*>(type_ctx.get_session());
|
|
if (OB_ISNULL(session)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("cast basic session to sql session failed", K(ret));
|
|
} else if (type1.is_null() || type2.is_null()) {
|
|
type.set_null();
|
|
} else {
|
|
bool not_int_flag = true;
|
|
if (type2.is_literal()) {
|
|
ObObjTypeClass target_tc = type1.get_type_class();
|
|
switch(target_tc) {
|
|
case ObIntTC: {
|
|
type.set_int();
|
|
type.set_scale(type1.get_scale());
|
|
not_int_flag = false;
|
|
break;
|
|
}
|
|
case ObUIntTC:
|
|
case ObBitTC:
|
|
case ObYearTC: {
|
|
type.set_uint64();
|
|
type.set_scale(type1.get_scale());
|
|
not_int_flag = false;
|
|
break;
|
|
}
|
|
case ObNumberTC: {
|
|
if (type1.is_unumber()) {
|
|
type.set_unumber();
|
|
} else {
|
|
type.set_number();
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
if (type1.is_ufloat() || type1.is_udouble()) {
|
|
type.set_udouble();
|
|
} else {
|
|
type.set_double();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
const ObObj& obj2 = type2.get_param();
|
|
ObArenaAllocator oballocator(ObModIds::BLOCK_ALLOC);
|
|
ObCastMode cast_mode = CM_NONE;
|
|
ObCollationType cast_coll_type = type_ctx.get_coll_type();
|
|
const ObDataTypeCastParams dtc_params =
|
|
ObBasicSessionInfo::create_dtc_params(session);
|
|
if (FAILEDx(ObSQLUtils::get_default_cast_mode(session, cast_mode))) {
|
|
LOG_WARN("failed to get default cast mode", K(ret));
|
|
}
|
|
ObCastCtx cast_ctx(&oballocator,
|
|
&dtc_params,
|
|
0,
|
|
cast_mode,
|
|
cast_coll_type);
|
|
int64_t scale_val = 0;
|
|
EXPR_GET_INT64_V2(obj2, scale_val);
|
|
|
|
if (0 <= scale_val) {
|
|
if (OB_SUCC(ret)) {
|
|
if (not_int_flag) {
|
|
if (OB_UNLIKELY(lib::is_oracle_mode())) {
|
|
type.set_scale(static_cast<int16_t>(GET_SCALE_FOR_DEDUCE_ORACLE(scale_val)));
|
|
} else {
|
|
type.set_scale(static_cast<int16_t>(GET_SCALE_FOR_DEDUCE(scale_val)));
|
|
}
|
|
ObPrecision precision = static_cast<ObPrecision>
|
|
(type1.get_precision() - type1.get_scale() + scale_val + 1);
|
|
//防御可能出现的没有设置precision的decimal 或者scale_val 为负数
|
|
precision = std::max(static_cast<int16_t>(-1), precision);
|
|
type.set_precision(precision);
|
|
} else { /* do nothing */}
|
|
} else if (ret == OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD ||
|
|
ret == OB_ERR_DATA_TRUNCATED){
|
|
// cast obj2 to int failed, just set scale to SCALE_UNKNOWN_YET
|
|
type.set_scale(SCALE_UNKNOWN_YET);
|
|
type.set_precision(PRECISION_UNKNOWN_YET);
|
|
ret = OB_SUCCESS;
|
|
} else {
|
|
// do nothing
|
|
}
|
|
} else {
|
|
type.set_scale(SCALE_UNKNOWN_YET);
|
|
type.set_precision(PRECISION_UNKNOWN_YET);
|
|
ret = OB_SUCCESS;
|
|
}
|
|
} else {
|
|
ObObjType expr1_ty = type1.get_type();
|
|
if (ObNumberType == expr1_ty || ObUNumberType == expr1_ty) {
|
|
type.set_type(expr1_ty);
|
|
} else if ((expr1_ty >= ObUTinyIntType && expr1_ty <= ObUInt64Type) ||
|
|
(expr1_ty >= ObUFloatType && expr1_ty <= ObUDoubleType) ||
|
|
(expr1_ty == ObYearType || expr1_ty == ObBitType)) {
|
|
type.set_udouble();
|
|
} else {
|
|
type.set_double();
|
|
}
|
|
if (type1.is_numeric_type() || ob_is_temporal_type(type1.get_type())) {
|
|
type.set_scale(type1.get_scale());
|
|
type.set_precision(type1.get_precision());
|
|
} else {
|
|
type.set_scale(SCALE_UNKNOWN_YET);
|
|
}
|
|
}
|
|
type1.set_calc_type(type.get_type());
|
|
type2.set_calc_type(ObIntType);
|
|
|
|
ObExprOperator::calc_result_flag2(type, type1, type2);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprTruncate::set_trunc_val(common::ObObj &result,
|
|
common::number::ObNumber &nmb,
|
|
ObExprCtx &expr_ctx,
|
|
ObObjType res_type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObObj tmp_obj;
|
|
tmp_obj.set_number(nmb);
|
|
EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE)
|
|
switch(res_type) {
|
|
case ObIntType: {
|
|
int64_t ival = 0;
|
|
EXPR_GET_INT64_V2(tmp_obj, ival);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_int(ival);
|
|
}
|
|
break;
|
|
}
|
|
case ObUInt64Type: {
|
|
uint64_t uval = 0;
|
|
EXPR_GET_UINT64_V2(tmp_obj, uval);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_uint64(uval);
|
|
}
|
|
break;
|
|
}
|
|
case ObFloatType: {
|
|
float fval = 0.0;
|
|
EXPR_GET_FLOAT_V2(tmp_obj, fval);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_float(fval);
|
|
}
|
|
break;
|
|
}
|
|
case ObUFloatType: {
|
|
float fval = 0.0;
|
|
EXPR_GET_FLOAT_V2(tmp_obj, fval);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_ufloat(fval);
|
|
}
|
|
break;
|
|
}
|
|
case ObDoubleType: {
|
|
double dval = 0.0;
|
|
EXPR_GET_DOUBLE_V2(tmp_obj, dval);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_double(dval);
|
|
}
|
|
break;
|
|
}
|
|
case ObUDoubleType: {
|
|
double dval = 0.0;
|
|
EXPR_GET_DOUBLE_V2(tmp_obj, dval);
|
|
if (OB_SUCC(ret)) {
|
|
result.set_udouble(dval);
|
|
}
|
|
break;
|
|
}
|
|
case ObNumberType: {
|
|
result.set_number(nmb);
|
|
break;
|
|
}
|
|
case ObUNumberType: {
|
|
result.set_unumber(nmb);
|
|
break;
|
|
}
|
|
default: {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected result type", K(ret), K(res_type));
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int calc_truncate_expr(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res_datum)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const ObObjType res_type = expr.datum_meta_.type_;
|
|
const ObObjType arg_type = expr.args_[0]->datum_meta_.type_;
|
|
// truncate(x, d)
|
|
ObDatum *x_datum = NULL;
|
|
ObDatum *d_datum = NULL;
|
|
if (OB_FAIL(expr.args_[0]->eval(ctx, x_datum)) ||
|
|
OB_FAIL(expr.args_[1]->eval(ctx, d_datum))) {
|
|
LOG_WARN("eval arg failed", K(ret));
|
|
} else if (x_datum->is_null() || d_datum->is_null()) {
|
|
res_datum.set_null();
|
|
} else if (OB_UNLIKELY(res_type != arg_type)) {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected res_type or arg_type", K(ret), K(res_type), K(arg_type), K(expr));
|
|
} else {
|
|
const int64_t scale = d_datum->get_int();
|
|
switch (arg_type) {
|
|
case ObIntType: {
|
|
res_datum.set_int(ObExprUtil::trunc_integer(x_datum->get_int(), scale));
|
|
break;
|
|
}
|
|
case ObUInt64Type: {
|
|
res_datum.set_uint(ObExprUtil::trunc_integer(x_datum->get_uint(), scale));
|
|
break;
|
|
}
|
|
case ObUDoubleType:
|
|
case ObDoubleType: {
|
|
res_datum.set_double(ObExprUtil::trunc_double(x_datum->get_double(), scale));
|
|
break;
|
|
}
|
|
case ObUNumberType:
|
|
case ObNumberType: {
|
|
ObNumStackOnceAlloc tmp_alloc;
|
|
number::ObNumber arg_nmb(x_datum->get_number());
|
|
number::ObNumber res_nmb;
|
|
if (OB_FAIL(res_nmb.from(arg_nmb, tmp_alloc))) {
|
|
LOG_WARN("get nmb from arg failed", K(ret), K(arg_nmb));
|
|
} else if (OB_FAIL(res_nmb.trunc(lib::is_oracle_mode()
|
|
? GET_SCALE_FOR_CALC_ORACLE(scale)
|
|
: GET_SCALE_FOR_CALC(scale)))) {
|
|
LOG_WARN("trunc number failed", K(ret), K(res_nmb), K(scale));
|
|
} else {
|
|
res_datum.set_number(res_nmb);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
ret = OB_ERR_UNEXPECTED;
|
|
LOG_WARN("unexpected arg_type for trunc expr", K(ret), K(arg_type));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprTruncate::cg_expr(ObExprCGCtx &expr_cg_ctx, const ObRawExpr &raw_expr,
|
|
ObExpr &rt_expr) const
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
UNUSED(expr_cg_ctx);
|
|
UNUSED(raw_expr);
|
|
rt_expr.eval_func_ = calc_truncate_expr;
|
|
return ret;
|
|
}
|
|
} // namespace sql
|
|
} // namespace oceanbase
|