init push
This commit is contained in:
oceanbase-admin
487
src/sql/engine/expr/ob_expr_to_number.cpp
Normal file
487
src/sql/engine/expr/ob_expr_to_number.cpp
Normal file
@ -0,0 +1,487 @@
|
||||
/**
|
||||
* 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_to_number.h"
|
||||
#include "sql/engine/expr/ob_expr_util.h"
|
||||
#include "lib/number/ob_number_v2.h"
|
||||
#include "lib/worker.h"
|
||||
#include <ctype.h>
|
||||
|
||||
namespace oceanbase {
|
||||
using namespace common;
|
||||
|
||||
namespace sql {
|
||||
|
||||
ObExprToNumberBase::ObExprToNumberBase(common::ObIAllocator& alloc, const ObExprOperatorType type, const char* name)
|
||||
: ObFuncExprOperator(alloc, type, name, ONE_OR_TWO, NOT_ROW_DIMENSION)
|
||||
{}
|
||||
|
||||
ObExprToNumberBase::~ObExprToNumberBase()
|
||||
{}
|
||||
|
||||
int ObExprToNumberBase::calc_result_typeN(
|
||||
ObExprResType& type, ObExprResType* types, int64_t param_num, ObExprTypeCtx& type_ctx) const
|
||||
{
|
||||
UNUSED(type_ctx);
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_UNLIKELY(!lib::is_oracle_mode())) {
|
||||
ret = OB_ERR_FUNCTION_UNKNOWN;
|
||||
LOG_WARN("to_char only support on oracle mode", K(type), K(ret));
|
||||
} else if (OB_UNLIKELY(NOT_ROW_DIMENSION != row_dimension_)) {
|
||||
ret = OB_ERR_INVALID_TYPE_FOR_OP;
|
||||
LOG_WARN("invalid row_dimension_", K(row_dimension_), K(ret));
|
||||
} else if (OB_UNLIKELY(param_num != 1 && param_num != 2) || OB_ISNULL(types)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(types));
|
||||
} else {
|
||||
if (types[0].is_varchar_or_char()) {
|
||||
types[0].set_calc_collation_utf8();
|
||||
} else if (param_num == 2 || (!types[0].is_number() && !types[0].is_number_float())) {
|
||||
types[0].set_calc_type_default_varchar();
|
||||
}
|
||||
if (param_num == 2) {
|
||||
if (types[1].is_varchar_or_char()) {
|
||||
types[1].set_calc_collation_utf8();
|
||||
} else {
|
||||
types[1].set_calc_type_default_varchar();
|
||||
}
|
||||
}
|
||||
type.set_type(ObNumberType);
|
||||
type.set_scale(ORA_NUMBER_SCALE_UNKNOWN_YET);
|
||||
type.set_precision(PRECISION_UNKNOWN_YET);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
ObExprToNumber::ObExprToNumber(ObIAllocator& alloc) : ObExprToNumberBase(alloc, T_FUN_SYS_TO_NUMBER, N_TO_NUMBER)
|
||||
{}
|
||||
|
||||
ObExprToNumber::~ObExprToNumber()
|
||||
{}
|
||||
|
||||
int ObExprToNumber::calc_resultN(ObObj& result, const ObObj* objs, int64_t param_num, ObExprCtx& expr_ctx) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num != 1 && param_num != 2) || OB_ISNULL(objs)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs));
|
||||
} else if (OB_UNLIKELY(param_num == 2 && objs[1].get_string_len() >= MAX_FMT_STR_LEN)) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("fmt string is too long", K(ret), K(param_num), K(objs[1]));
|
||||
} else if (objs[0].is_null()) {
|
||||
result.set_null();
|
||||
} else {
|
||||
number::ObNumber res_nmb;
|
||||
const ObObjType& arg_type = objs[0].get_type();
|
||||
if (1 == param_num) {
|
||||
if (ob_is_varchar_or_char(arg_type, objs[0].get_collation_type())) {
|
||||
const ObString& str1 = objs[0].get_string();
|
||||
ObPrecision res_precision = -1;
|
||||
ObScale res_scale = -1;
|
||||
if (OB_FAIL(
|
||||
res_nmb.from_sci_opt(str1.ptr(), str1.length(), *(expr_ctx.calc_buf_), &res_precision, &res_scale))) {
|
||||
LOG_WARN("fail to calc function to_number", K(ret), K(str1));
|
||||
} else {
|
||||
result.set_number(res_nmb);
|
||||
}
|
||||
} else if (ObNumberTC == ob_obj_type_class(arg_type)) {
|
||||
if (OB_FAIL(res_nmb.from(objs[0].get_number(), *(expr_ctx.calc_buf_)))) {
|
||||
LOG_WARN("get nmb failed", K(ret));
|
||||
} else {
|
||||
result.set_number(res_nmb);
|
||||
}
|
||||
} else {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected arg type", K(ret), K(arg_type));
|
||||
}
|
||||
} else {
|
||||
const ObString& str1 = objs[0].get_string();
|
||||
const ObString& str2 = objs[1].get_string();
|
||||
if (OB_FAIL(calc_(str1, str2, *(expr_ctx.calc_buf_), res_nmb))) {
|
||||
LOG_WARN("calc to number failed", K(ret), K(str1), K(str2));
|
||||
} else {
|
||||
result.set_number(res_nmb);
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToNumber::calc_(
|
||||
const ObString& in_str, const ObString& in_fmt_str, ObIAllocator& alloc, number::ObNumber& res_nmb)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObPrecision res_precision = -1;
|
||||
ObScale res_scale = -1;
|
||||
number::ObNumberFmtModel fmt;
|
||||
int64_t length = in_fmt_str.length();
|
||||
const char* fmt_start = in_fmt_str.ptr();
|
||||
const char* fmt_end = fmt_start + length;
|
||||
char fmt_str[MAX_FMT_STR_LEN];
|
||||
int64_t i = 0;
|
||||
bool has_d = false;
|
||||
bool has_sign = false;
|
||||
bool has_currency = false;
|
||||
bool has_b = false;
|
||||
bool has_comma = false;
|
||||
bool has_x = false;
|
||||
int16_t dc_position = -1; // dot character
|
||||
int16_t sign_position = -1;
|
||||
int16_t fmt_len = 0;
|
||||
fmt.fmt_str_ = &fmt_str[0];
|
||||
|
||||
for (i = 0; ret == OB_SUCCESS && fmt_start < fmt_end; fmt_start++, ++i) {
|
||||
switch (fmt_start[0]) {
|
||||
case ',': {
|
||||
if (0 == i || has_d || has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("comma's position is invalid", K(ret), K(i), K(has_d));
|
||||
}
|
||||
fmt_str[fmt_len++] = ',';
|
||||
has_comma = true;
|
||||
break;
|
||||
}
|
||||
case 'D':
|
||||
case 'd':
|
||||
case '.': {
|
||||
if (has_d || has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("period apprears more than once", K(ret), K(i), K(has_d));
|
||||
} else {
|
||||
has_d = true;
|
||||
dc_position = fmt_len;
|
||||
fmt_str[fmt_len++] = '.';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case '$': {
|
||||
if (has_currency || has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("dollar sign apprear more than once", K(ret), K(i), K(has_currency));
|
||||
} else {
|
||||
has_currency = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case '0':
|
||||
case '9': {
|
||||
if (has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("dollar sign apprear more than once", K(ret), K(i), K(has_currency));
|
||||
}
|
||||
fmt_str[fmt_len++] = fmt_start[0];
|
||||
break;
|
||||
}
|
||||
case 'S':
|
||||
case 's': {
|
||||
/* sign can appear only in the first or last position of a number format model */
|
||||
if (has_sign || (i != 0 && i != length - 1) || has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("sign appears at wrong position ", K(ret), K(i), K(has_sign), K(length));
|
||||
} else {
|
||||
has_sign = true;
|
||||
sign_position = (i == 0 ? number::FmtFirst : number::FmtLast);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'B':
|
||||
case 'b': {
|
||||
if (has_b || has_x) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("B/b appear more than once ", K(ret), K(i), K(has_b));
|
||||
} else {
|
||||
has_b = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'x':
|
||||
case 'X': {
|
||||
fmt_str[fmt_len++] = fmt_start[0];
|
||||
has_x = true;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
LOG_WARN("invalid fmt character ", K(ret), K(i), K(fmt_start[0]));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
fmt.dc_position_ = dc_position;
|
||||
fmt.sign_position_ = sign_position;
|
||||
fmt.fmt_len_ = fmt_len;
|
||||
fmt.has_b_ = has_b;
|
||||
fmt.has_currency_ = has_currency;
|
||||
fmt.has_d_ = has_d;
|
||||
fmt.has_sign_ = has_sign;
|
||||
fmt.has_comma_ = has_comma;
|
||||
fmt.has_x_ = has_x;
|
||||
LOG_DEBUG("user number format model",
|
||||
K(dc_position),
|
||||
K(sign_position),
|
||||
K(fmt_len),
|
||||
K(fmt_str),
|
||||
K(has_currency),
|
||||
K(has_d),
|
||||
K(has_sign),
|
||||
K(in_str.ptr()));
|
||||
if (OB_FAIL(res_nmb.from(in_str.ptr(), in_str.length(), alloc, &fmt, &res_precision, &res_scale))) {
|
||||
LOG_WARN("fail to calc function to_number with", K(ret), K(in_str), K(in_fmt_str));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToNumber::calc_tonumber_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
// to_number(ori, fmt)
|
||||
ObDatum* ori = NULL;
|
||||
ObDatum* fmt = NULL;
|
||||
bool is_null = false;
|
||||
if (OB_UNLIKELY(1 != expr.arg_cnt_ && 2 != expr.arg_cnt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("invalid arg cnt", K(ret), K(expr.arg_cnt_));
|
||||
} else if (OB_FAIL(expr.eval_param_value(ctx, ori, fmt))) {
|
||||
LOG_WARN("eval param failed", K(ret));
|
||||
} else if (OB_UNLIKELY(expr.arg_cnt_ == 2 && fmt->get_string().length() >= MAX_FMT_STR_LEN)) {
|
||||
ret = OB_ERR_INVALID_NUMBER_FORMAT_MODEL;
|
||||
} else if (ori->is_null()) {
|
||||
res_datum.set_null();
|
||||
} else {
|
||||
const ObObjType& ori_type = expr.args_[0]->datum_meta_.type_;
|
||||
const ObCollationType& ori_cs_type = expr.args_[0]->datum_meta_.cs_type_;
|
||||
ObIAllocator& calc_alloc = ctx.get_reset_tmp_alloc();
|
||||
number::ObNumber res_nmb;
|
||||
if (1 == expr.arg_cnt_) {
|
||||
if (ob_is_varchar_or_char(ori_type, ori_cs_type)) {
|
||||
const ObString& ori_str = ori->get_string();
|
||||
ObNumStackOnceAlloc tmp_alloc;
|
||||
ObPrecision res_precision = -1;
|
||||
ObScale res_scale = -1;
|
||||
if (OB_FAIL(res_nmb.from_sci_opt(ori_str.ptr(), ori_str.length(), tmp_alloc, &res_precision, &res_scale))) {
|
||||
LOG_WARN("fail to calc function to_number", K(ret), K(ori_str));
|
||||
} else {
|
||||
res_datum.set_number(res_nmb);
|
||||
}
|
||||
} else if (ObNumberTC == ob_obj_type_class(ori_type)) {
|
||||
ObNumStackOnceAlloc tmp_alloc;
|
||||
if (OB_FAIL(res_nmb.from(ori->get_number(), tmp_alloc))) {
|
||||
LOG_WARN("get nmb failed", K(ret));
|
||||
} else {
|
||||
res_datum.set_number(res_nmb);
|
||||
}
|
||||
} else {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected arg type", K(ret), K(ori_type));
|
||||
}
|
||||
} else {
|
||||
if (OB_ISNULL(fmt)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("fmt datum is NULL", K(ret));
|
||||
} else {
|
||||
const ObString& ori_str = ori->get_string();
|
||||
const ObString& fmt_str = fmt->get_string();
|
||||
if (OB_FAIL(calc_(ori_str, fmt_str, calc_alloc, res_nmb))) {
|
||||
LOG_WARN("calc to number failed", K(ret), K(ori_str), K(fmt_str));
|
||||
} else {
|
||||
res_datum.set_number(res_nmb);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToNumber::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_tonumber_expr;
|
||||
return ret;
|
||||
}
|
||||
|
||||
ObExprToBinaryFloat::ObExprToBinaryFloat(ObIAllocator& alloc)
|
||||
: ObExprToNumberBase(alloc, T_FUN_SYS_TO_BINARY_FLOAT, N_TO_BINARY_FLOAT)
|
||||
{}
|
||||
|
||||
ObExprToBinaryFloat::~ObExprToBinaryFloat()
|
||||
{}
|
||||
|
||||
int ObExprToBinaryFloat::calc_result_typeN(
|
||||
ObExprResType& type, ObExprResType* types, int64_t param_num, ObExprTypeCtx& type_ctx) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const ObSQLSessionInfo* session = type_ctx.get_session();
|
||||
if (OB_ISNULL(session)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("session is NULL", K(ret));
|
||||
} else if (OB_UNLIKELY(param_num > 1)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(types));
|
||||
} else if (OB_FAIL(ObExprToNumberBase::calc_result_typeN(type, types, param_num, type_ctx))) {
|
||||
LOG_WARN("fail to calc_result_typeN", K(ret));
|
||||
} else if (OB_FAIL(ObObjCaster::can_cast_in_oracle_mode(ObFloatTC, types[0].get_type_class()))) {
|
||||
LOG_WARN("input type can not cast to binary_float", K(types[0].get_type()), K(ret));
|
||||
} else {
|
||||
if (session->use_static_typing_engine()) {
|
||||
types[0].set_calc_type(ObFloatType);
|
||||
} else {
|
||||
if (types[0].is_varchar_or_char()) {
|
||||
types[0].set_calc_collation_utf8();
|
||||
} else if (!types[0].is_float() && !types[0].is_double()) {
|
||||
types[0].set_calc_type_default_varchar();
|
||||
}
|
||||
}
|
||||
type.set_type(ObFloatType);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryFloat::calc_resultN(ObObj& result, const ObObj* objs, int64_t param_num, ObExprCtx& expr_ctx) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num != 1) || OB_ISNULL(objs)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs));
|
||||
} else if (objs[0].is_null()) {
|
||||
result.set_null();
|
||||
} else {
|
||||
float value = 0;
|
||||
EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
|
||||
EXPR_GET_FLOAT_V2(objs[0], value);
|
||||
if (OB_SUCC(ret)) {
|
||||
result.set_float(value);
|
||||
}
|
||||
LOG_DEBUG("finish to_binary_float", K(ret), K(param_num), K(objs[0]), K(value), K(result.get_float()));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryFloat::calc_to_binaryfloat_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
// to_number(ori, fmt)
|
||||
ObDatum* ori = NULL;
|
||||
bool is_null = false;
|
||||
if (OB_UNLIKELY(1 != expr.arg_cnt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("invalid arg cnt", K(ret), K(expr.arg_cnt_));
|
||||
} else if (OB_FAIL(expr.eval_param_value(ctx, ori))) {
|
||||
LOG_WARN("eval param failed", K(ret));
|
||||
} else if (ori->is_null()) {
|
||||
res_datum.set_null();
|
||||
} else {
|
||||
res_datum.set_float(ori->get_float());
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryFloat::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_to_binaryfloat_expr;
|
||||
return ret;
|
||||
}
|
||||
|
||||
ObExprToBinaryDouble::ObExprToBinaryDouble(ObIAllocator& alloc)
|
||||
: ObExprToNumberBase(alloc, T_FUN_SYS_TO_BINARY_DOUBLE, N_TO_BINARY_DOUBLE)
|
||||
{}
|
||||
|
||||
ObExprToBinaryDouble::~ObExprToBinaryDouble()
|
||||
{}
|
||||
|
||||
int ObExprToBinaryDouble::calc_result_typeN(
|
||||
ObExprResType& type, ObExprResType* types, int64_t param_num, ObExprTypeCtx& type_ctx) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const ObSQLSessionInfo* session = type_ctx.get_session();
|
||||
if (OB_ISNULL(session)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("session is NULL", K(ret));
|
||||
} else if (OB_UNLIKELY(param_num > 1)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(types));
|
||||
} else if (OB_FAIL(ObExprToNumberBase::calc_result_typeN(type, types, param_num, type_ctx))) {
|
||||
LOG_WARN("fail to calc_result_typeN", K(ret));
|
||||
} else if (OB_FAIL(ObObjCaster::can_cast_in_oracle_mode(ObDoubleTC, types[0].get_type_class()))) {
|
||||
LOG_WARN("input type can not cast to binary_double", K(types[0].get_type()), K(ret));
|
||||
} else {
|
||||
if (session->use_static_typing_engine()) {
|
||||
types[0].set_calc_type(ObDoubleType);
|
||||
} else {
|
||||
if (types[0].is_varchar_or_char()) {
|
||||
types[0].set_calc_collation_utf8();
|
||||
} else if (!types[0].is_float() && !types[0].is_double()) {
|
||||
types[0].set_calc_type_default_varchar();
|
||||
}
|
||||
}
|
||||
type.set_type(ObDoubleType);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryDouble::calc_resultN(ObObj& result, const ObObj* objs, int64_t param_num, ObExprCtx& expr_ctx) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_ISNULL(expr_ctx.calc_buf_) || OB_UNLIKELY(param_num != 1) || OB_ISNULL(objs)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("Invalid argument", K(ret), K(param_num), K(expr_ctx.calc_buf_), K(objs));
|
||||
} else if (objs[0].is_null()) {
|
||||
result.set_null();
|
||||
} else {
|
||||
double value = 0;
|
||||
EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
|
||||
EXPR_GET_DOUBLE_V2(objs[0], value);
|
||||
if (OB_SUCC(ret)) {
|
||||
result.set_double(value);
|
||||
}
|
||||
LOG_DEBUG("finish to_binary_double", K(ret), K(param_num), K(objs[0]), K(value));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryDouble::calc_to_binarydouble_expr(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& res_datum)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
// to_number(ori, fmt)
|
||||
ObDatum* ori = NULL;
|
||||
if (OB_UNLIKELY(1 != expr.arg_cnt_)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("invalid arg cnt", K(ret), K(expr.arg_cnt_));
|
||||
} else if (OB_FAIL(expr.eval_param_value(ctx, ori))) {
|
||||
LOG_WARN("eval param failed", K(ret));
|
||||
} else if (ori->is_null()) {
|
||||
res_datum.set_null();
|
||||
} else {
|
||||
res_datum.set_double(ori->get_double());
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObExprToBinaryDouble::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_to_binarydouble_expr;
|
||||
return ret;
|
||||
}
|
||||
|
||||
} /* namespace sql */
|
||||
} /* namespace oceanbase */
|
||||
Reference in New Issue
Block a user