hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
080ca3a2dddea97caec905c683ee0518d177d00f
oceanbase/src/sql/engine/expr/ob_expr_date_add.cpp
wangzelin.wzl 93a1074b0c patch 4.0
2022-10-24 17:57:12 +08:00

593 lines
22 KiB
C++
Raw Blame History

/**
* 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_date_add.h"
#include "lib/ob_date_unit_type.h"
#include "lib/timezone/ob_time_convert.h"
#include "lib/ob_name_def.h"
#include "share/object/ob_obj_cast.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/engine/ob_exec_context.h"
#include "ob_datum_cast.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
ObExprDateAdjust::ObExprDateAdjust(ObIAllocator &alloc,
ObExprOperatorType type,
const char *name,
int32_t param_num,
int32_t dimension)
: ObFuncExprOperator(alloc, type, name, param_num, dimension)
{
}
ObExprDateAdjust::~ObExprDateAdjust()
{
}
int ObExprDateAdjust::calc_result_type3(ObExprResType &type,
ObExprResType &date,
ObExprResType &interval,
ObExprResType &unit,
ObExprTypeCtx &type_ctx) const
{
UNUSED(type_ctx);
UNUSED(interval);
//if date is ObDateType, and date_uint contains no hour / minute / second / microsecond,
//the result type should be date, not datetime or timestamp.
// date_add('2012-2-29', interval '-1000000' microsecond) => 2012-02-28 23:59:59 .
// date_add('2012-2-29', interval '-100000' microsecond) => 2012-02-28 23:59:59.900000 .
// date_add('2012-2-29 00:00:00.100', interval '-100000' microsecond) => 2012-02-29 00:00:00 .
// so scale of literal datetime or date should be -1.
//literal -> cast to string -> is date or datetime format?
int ret = OB_SUCCESS;
ObDateUnitType unit_type = static_cast<ObDateUnitType>(unit.get_param().get_int());
ObExprResType res_date = date;
const ObSQLSessionInfo *session = static_cast<const ObSQLSessionInfo*>(type_ctx.get_session());
if (OB_ISNULL(session)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session is null", K(ret));
} else if (OB_UNLIKELY(ObNullType == date.get_type())) {
type.set_null();
} else {
unit.set_calc_type(ObIntType);
if (ObDateTimeType == date.get_type() || ObTimestampType == date.get_type()) {
type.set_datetime();
date.set_calc_type(ObDateTimeType);
} else if (ObDateType == date.get_type()) {
if (DATE_UNIT_YEAR == unit_type || DATE_UNIT_MONTH == unit_type
|| DATE_UNIT_DAY == unit_type || DATE_UNIT_YEAR_MONTH == unit_type
|| DATE_UNIT_WEEK == unit_type || DATE_UNIT_QUARTER == unit_type) {
type.set_date();
} else {
type.set_datetime();
}
} else if (ObTimeType == date.get_type()) {
type.set_time();
} else {
date.set_calc_type(ObVarcharType);
type.set_varchar();
type.set_length(DATETIME_MAX_LENGTH);
ret = aggregate_charsets_for_string_result(type, &date, 1, type_ctx.get_coll_type());
}
interval.set_calc_type(ObVarcharType);
if (OB_SUCC(ret)) {
if (lib::is_oracle_mode()) {
type.set_scale(static_cast<ObScale>(OB_MAX_DATE_PRECISION));
} else { // mysql mode
ObScale scale = 0;
if (DATE_UNIT_MICROSECOND == unit_type
|| DATE_UNIT_SECOND_MICROSECOND == unit_type || DATE_UNIT_MINUTE_MICROSECOND == unit_type
|| DATE_UNIT_HOUR_MICROSECOND == unit_type || DATE_UNIT_DAY_MICROSECOND == unit_type) {
scale = OB_MAX_DATETIME_PRECISION;
} else if (DATE_UNIT_SECOND == unit_type) {
if (0 <= interval.get_scale()) {
scale = std::min(static_cast<ObScale>(OB_MAX_DATETIME_PRECISION),
interval.get_scale());
} else {
scale = OB_MAX_DATETIME_PRECISION;
}
}
if (date.is_datetime() || date.is_timestamp() || date.is_time()) {
scale = std::max(date.get_scale(), scale);
} else if (date.is_date()) {
if ((DATE_UNIT_DAY <= unit_type && unit_type <= DATE_UNIT_YEAR)
|| DATE_UNIT_YEAR_MONTH == unit_type) {
scale = 0;
} else {
// do nothing
}
} else {
// here res type is varchar
scale = -1;
}
type.set_scale(scale);
}
}
}
// todo(jiuren)/(yeti):
// for column :
// date_unit not has microsecond and no default scale but the result has mircrosecond, so the scale should be result_scale
// such as: select date_add(a, INTERVAL 0.1 second);
return ret;
}
int ObExprDateAdjust::calc_date_adjust(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum,
bool is_add)
{
int ret = OB_SUCCESS;
const ObSQLSessionInfo *session = NULL;
const ObObjType res_type = expr.datum_meta_.type_;
const ObObjType date_type = expr.args_[0]->datum_meta_.type_;
ObDatum *date = NULL;
ObDatum *interval = NULL;
ObDatum *unit = NULL;
bool is_json = (expr.args_[0]->args_ != NULL) && (expr.args_[0]->args_[0]->datum_meta_.type_ == ObJsonType);
if (OB_ISNULL(session = ctx.exec_ctx_.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session is null", K(ret));
} else if (OB_FAIL(expr.eval_param_value(ctx, date, interval, unit))) {
LOG_WARN("eval param value failed");
} else if (OB_UNLIKELY(date->is_null() || interval->is_null())
|| ObNullType == res_type) {
expr_datum.set_null();
} else {
int64_t dt_val = 0;
ObString interval_val = interval->get_string();
int64_t unit_value = unit->get_int();
ObDateUnitType unit_val = static_cast<ObDateUnitType>(unit_value);
int64_t res_dt_val = 0;
bool has_set_value = false;
if (ObDateTimeType == date_type || ObTimestampType == date_type) {
dt_val = date->get_datetime();
} else {
ObTime ob_time;
ObDateSqlMode date_sql_mode;
ObTimeConvertCtx cvrt_ctx(get_timezone_info(session), false);
date_sql_mode.init(session->get_sql_mode());
if (is_json) { // json to string will add quote automatically, here should take off quote
ObString str = date->get_string();
if (str.length() >= 3) { // 2 quote and content length >= 1
date->set_string(str.ptr() + 1, str.length() - 1);
}
}
if (OB_FAIL(ob_datum_to_ob_time_with_date(*date, date_type,
get_timezone_info(session),
ob_time,
get_cur_time(ctx.exec_ctx_.get_physical_plan_ctx()),
false, date_sql_mode))) {
uint64_t cast_mode = 0;
ObSQLUtils::get_default_cast_mode(session->get_stmt_type(), session, cast_mode);
if (CM_IS_WARN_ON_FAIL(cast_mode)) {
expr_datum.set_null();
ret = OB_SUCCESS;
has_set_value = true;
} else {
LOG_WARN("datum to ob time failed", K(ret), K(date->get_string()), K(date_type));
}
} else if (OB_FAIL(ObTimeConverter::ob_time_to_datetime(ob_time, cvrt_ctx, dt_val))) {
LOG_WARN("ob time to datetime failed", K(ret));
}
}
if (OB_SUCC(ret) && !has_set_value) {
ObDateSqlMode date_sql_mode;
date_sql_mode.init(session->get_sql_mode());
if (OB_UNLIKELY(ObTimeConverter::ZERO_DATETIME == dt_val)) {
expr_datum.set_null();
} else if (OB_FAIL(ObTimeConverter::date_adjust(dt_val, interval_val, unit_val, res_dt_val,
is_add, date_sql_mode))) {
if (OB_UNLIKELY(OB_INVALID_DATE_VALUE == ret)) {
expr_datum.set_null();
ret = OB_SUCCESS;
}
} else if (ObDateType == res_type) {
int32_t d_val = 0;
if (OB_FAIL(ObTimeConverter::datetime_to_date(res_dt_val, NULL, d_val))) {
LOG_WARN("failed to cast datetime to date ", K(res_dt_val), K(ret));
} else {
expr_datum.set_date(d_val);
}
} else if (ObTimeType == res_type) {
int64_t cur_date = 0;
cur_date = (dt_val / USECS_PER_DAY) * USECS_PER_DAY;
if (res_dt_val - cur_date > OB_MAX_TIME || res_dt_val - cur_date < -OB_MAX_TIME) {
expr_datum.set_null();
} else if (((unit_val >= DATE_UNIT_MONTH && unit_val <= DATE_UNIT_YEAR)
|| DATE_UNIT_YEAR_MONTH == unit_val) && res_dt_val != dt_val) {
expr_datum.set_null();
} else {
expr_datum.set_time(res_dt_val - cur_date);
}
} else if (ObDateTimeType == res_type) {
expr_datum.set_datetime(res_dt_val);
} else { //RETURN STRING TYPE
ObObjType res_date;
bool dt_flag = false;
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS != (tmp_ret =
ObTimeConverter::str_is_date_format(date->get_string(), dt_flag))) {
uint64_t cast_mode = 0;
ObSQLUtils::get_default_cast_mode(session->get_stmt_type(), session, cast_mode);
if (CM_IS_WARN_ON_FAIL(cast_mode) && OB_INVALID_DATE_FORMAT == tmp_ret) {
expr_datum.set_null();
has_set_value = true;
} else {
ret = tmp_ret;
LOG_WARN("failed to cast str to datetime format", K(ret));
}
} else {
if (dt_flag) {
res_date = ObDateType;
} else {
res_date = ObDateTimeType;
}
}
if (OB_SUCC(ret) && !has_set_value) {
if (ObDateType == res_date && (DATE_UNIT_YEAR == unit_val
|| DATE_UNIT_MONTH == unit_val
|| DATE_UNIT_DAY == unit_val || DATE_UNIT_YEAR_MONTH == unit_val
|| DATE_UNIT_WEEK == unit_val || DATE_UNIT_QUARTER == unit_val)) {
int32_t d_val = 0;
if (OB_FAIL(ObTimeConverter::datetime_to_date(res_dt_val, NULL, d_val))) {
LOG_WARN("failed to cast datetime to date ", K(res_dt_val), K(ret));
} else {
ObTime ob_time;
const int64_t date_buf_len = DATETIME_MAX_LENGTH + 1;
char *buf = expr.get_str_res_mem(ctx, date_buf_len);
int64_t pos = 0;
if (OB_ISNULL(buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret));
} else if (OB_FAIL(ObTimeConverter::date_to_ob_time(d_val, ob_time))) {
LOG_WARN("failed to convert days to ob time", K(ret));
} else if (OB_FAIL(ObTimeConverter::ob_time_to_str(ob_time, DT_TYPE_DATE, 0, buf,
date_buf_len, pos, true))) {
LOG_WARN("failed to convert ob time to string", K(ret));
} else {
expr_datum.ptr_ = buf;
expr_datum.pack_ = static_cast<uint32_t>(pos);
}
}
} else {
const int64_t datetime_buf_len = DATETIME_MAX_LENGTH + 1;
char *buf = expr.get_str_res_mem(ctx, datetime_buf_len);
int64_t pos = 0;
ObString format;
if (OB_ISNULL(buf)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret));
} else if (OB_FAIL(ObTimeConverter::datetime_to_str(res_dt_val, NULL,
format, -1, buf,
datetime_buf_len, pos, true))) {
LOG_WARN("failed to cast object to ObVarcharType ", K(ret));
} else {
expr_datum.ptr_ = buf;
expr_datum.pack_ = static_cast<uint32_t>(pos);
}
}
}
}
}
}
return ret;
}
ObExprDateAdd::ObExprDateAdd(ObIAllocator &alloc)
: ObExprDateAdjust(alloc, T_FUN_SYS_DATE_ADD, N_DATE_ADD, 3, NOT_ROW_DIMENSION)
{}
int ObExprDateAdd::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr, ObExpr &rt_expr) const
{
UNUSED(op_cg_ctx);
UNUSED(raw_expr);
int ret = OB_SUCCESS;
if (rt_expr.arg_cnt_ != 3) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("date_add expr should have 3 params", K(ret), K(rt_expr.arg_cnt_));
} else if (OB_ISNULL(rt_expr.args_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("children of date_add expr is null", K(ret), K(rt_expr.args_));
} else if (OB_ISNULL(rt_expr.args_[0]) ||
OB_ISNULL(rt_expr.args_[1]) ||
OB_ISNULL(rt_expr.args_[2])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child of date_add expr is null", K(ret), K(rt_expr.args_[0]),
K(rt_expr.args_[1]), K(rt_expr.args_[2]));
} else {
rt_expr.eval_func_ = ObExprDateAdd::calc_date_add;
}
return ret;
}
int ObExprDateAdd::calc_date_add(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
{
return ObExprDateAdjust::calc_date_adjust(expr, ctx, expr_datum, true /* is_add */);
}
ObExprDateSub::ObExprDateSub(ObIAllocator &alloc)
: ObExprDateAdjust(alloc, T_FUN_SYS_DATE_SUB, N_DATE_SUB, 3, NOT_ROW_DIMENSION)
{}
int ObExprDateSub::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr, ObExpr &rt_expr) const
{
UNUSED(op_cg_ctx);
UNUSED(raw_expr);
int ret = OB_SUCCESS;
if (rt_expr.arg_cnt_ != 3) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("date_sub expr should have 3 params", K(ret), K(rt_expr.arg_cnt_));
} else if (OB_ISNULL(rt_expr.args_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("children of date_sub expr is null", K(ret), K(rt_expr.args_));
} else if (OB_ISNULL(rt_expr.args_[0]) ||
OB_ISNULL(rt_expr.args_[1]) ||
OB_ISNULL(rt_expr.args_[2])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child of date_sub expr is null", K(ret), K(rt_expr.args_[0]),
K(rt_expr.args_[1]), K(rt_expr.args_[2]));
} else {
rt_expr.eval_func_ = ObExprDateSub::calc_date_sub;
}
return ret;
}
int ObExprDateSub::calc_date_sub(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
{
return ObExprDateAdjust::calc_date_adjust(expr, ctx, expr_datum, false /* is_add */);
}
ObExprAddMonths::ObExprAddMonths(ObIAllocator &alloc)
: ObFuncExprOperator(alloc, T_FUN_SYS_ADD_MONTHS, N_ADD_MONTHS, 2, NOT_ROW_DIMENSION)
{}
int ObExprAddMonths::calc_result_type2(ObExprResType &type,
ObExprResType &type1,
ObExprResType &type2,
common::ObExprTypeCtx &type_ctx) const
{
int ret = OB_SUCCESS;
UNUSED(type_ctx);
type.set_datetime();
type.set_scale(OB_MAX_DATE_PRECISION);
type1.set_calc_type(ObDateTimeType);
type1.set_calc_scale(OB_MAX_DATETIME_PRECISION);
type2.set_calc_type(ObNumberType);
return ret;
}
int ObExprAddMonths::cg_expr(ObExprCGCtx &op_cg_ctx,
const ObRawExpr &raw_expr,
ObExpr &rt_expr) const
{
UNUSED(op_cg_ctx);
UNUSED(raw_expr);
int ret = OB_SUCCESS;
if (rt_expr.arg_cnt_ != 2) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("add_months expr should have 2 params", K(ret), K(rt_expr.arg_cnt_));
} else if (OB_ISNULL(rt_expr.args_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("children of add_months expr is null", K(ret), K(rt_expr.args_));
} else if (OB_ISNULL(rt_expr.args_[0]) ||
OB_ISNULL(rt_expr.args_[1])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child of add_months expr is null", K(ret), K(rt_expr.args_[0]), K(rt_expr.args_[1]));
} else {
rt_expr.eval_func_ = ObExprAddMonths::calc_add_months;
}
return ret;
}
int ObExprAddMonths::calc_add_months(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
{
int ret = OB_SUCCESS;
ObDatum *param1 = NULL;
ObDatum *param2 = NULL;
if (OB_FAIL(expr.args_[0]->eval(ctx, param1))) {
LOG_WARN("eval first param value failed");
} else if (param1->is_null()) { //短路计算
expr_datum.set_null();
} else if (OB_FAIL(expr.args_[1]->eval(ctx, param2))) {
LOG_WARN("eval second param value failed");
} else if (param2->is_null()) {
expr_datum.set_null();
} else {
int64_t ori_date_utc = param1->get_datetime();
number::ObNumber months(param2->get_number());
int64_t months_int = 0;
int64_t res_date_utc = 0;
if (OB_FAIL(months.extract_valid_int64_with_trunc(months_int))) {
LOG_WARN("fail to do round", K(ret));
} else if (OB_FAIL(ObTimeConverter::date_add_nmonth(ori_date_utc, months_int,
res_date_utc, true))) {
LOG_WARN("fail to date add nmonth", K(ret));
} else {
expr_datum.set_datetime(res_date_utc);
}
}
return ret;
}
ObExprLastDay::ObExprLastDay(ObIAllocator &alloc)
: ObFuncExprOperator(alloc, T_FUN_SYS_LAST_DAY, N_LAST_DAY, 1, NOT_ROW_DIMENSION)
{}
int ObExprLastDay::calc_result_type1(ObExprResType &type,
ObExprResType &type1,
common::ObExprTypeCtx &type_ctx) const
{
int ret = OB_SUCCESS;
UNUSED(type_ctx);
bool accept_input_type = type1.is_null()
|| ob_is_string_tc(type1.get_type())
|| type1.is_datetime()
|| type1.is_otimestamp_type()
|| is_mysql_mode();
if (OB_UNLIKELY(!accept_input_type)) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("inconsistent type", K(ret), K(type1));
} else {
if (is_oracle_mode()) {
type.set_datetime();
} else {
type.set_date();
}
type.set_scale(OB_MAX_DATE_PRECISION);
type1.set_calc_type(ObDateTimeType);
type1.set_calc_scale(OB_MAX_DATETIME_PRECISION);
}
return ret;
}
int ObExprLastDay::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr, ObExpr &rt_expr) const
{
UNUSED(op_cg_ctx);
UNUSED(raw_expr);
int ret = OB_SUCCESS;
if (rt_expr.arg_cnt_ != 1) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("lastday expr should have 1 param", K(ret), K(rt_expr.arg_cnt_));
} else if (OB_ISNULL(rt_expr.args_) || OB_ISNULL(rt_expr.args_[0])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("children of lastday expr is null", K(ret), K(rt_expr.args_), K(rt_expr.args_[0]));
} else {
rt_expr.eval_func_ = ObExprLastDay::calc_last_day;
}
return ret;
}
int ObExprLastDay::calc_last_day(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
{
int ret = OB_SUCCESS;
ObDatum *param1 = NULL;
ObSQLSessionInfo *session = NULL;
if (OB_ISNULL(session = ctx.exec_ctx_.get_my_session())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("session is null", K(ret));
} else if (OB_FAIL(expr.args_[0]->eval(ctx, param1))) {
LOG_WARN("eval first param value failed");
} else if (param1->is_null()) {
expr_datum.set_null();
} else {
const ObObjType res_type = is_oracle_mode() ? ObDateTimeType : ObDateType;
int64_t ori_date_utc = param1->get_datetime();
int64_t res_date_utc = 0;
ObDateSqlMode date_sql_mode;
date_sql_mode.init(session->get_sql_mode());
if (OB_FAIL(ObTimeConverter::calc_last_date_of_the_month(ori_date_utc, res_date_utc,
res_type, !is_no_zero_in_date(session->get_sql_mode()), date_sql_mode))) {
LOG_WARN("fail to calc last mday", K(ret), K(ori_date_utc), K(res_date_utc));
if (!is_oracle_mode()) {
uint64_t cast_mode = 0;
ObSQLUtils::get_default_cast_mode(session->get_stmt_type(), session, cast_mode);
if (CM_IS_WARN_ON_FAIL(cast_mode)) {
expr_datum.set_null();
ret = OB_SUCCESS;
}
}
} else {
if (is_oracle_mode()) {
expr_datum.set_datetime(res_date_utc);
} else {
expr_datum.set_date(static_cast<int32_t>(res_date_utc));
}
}
}
return ret;
}
ObExprNextDay::ObExprNextDay(ObIAllocator &alloc)
: ObFuncExprOperator(alloc, T_FUN_SYS_NEXT_DAY, N_NEXT_DAY, 2, NOT_ROW_DIMENSION)
{}
int ObExprNextDay::calc_result_type2(ObExprResType &type,
ObExprResType &type1,
ObExprResType &type2,
common::ObExprTypeCtx &type_ctx) const
{
int ret = OB_SUCCESS;
UNUSED(type_ctx);
bool accept_input_type = type1.is_null()
|| ob_is_string_tc(type1.get_type())
|| type1.is_datetime()
|| type1.is_otimestamp_type();
if (OB_UNLIKELY(!accept_input_type)) {
ret = OB_ERR_INVALID_TYPE_FOR_OP;
LOG_WARN("inconsistent type", K(ret), K(type1));
} else {
type.set_datetime();
type.set_scale(OB_MAX_DATE_PRECISION);
type1.set_calc_type(ObDateTimeType);
type1.set_calc_scale(OB_MAX_DATETIME_PRECISION);
type2.set_calc_type(ObVarcharType);
}
return ret;
}
int ObExprNextDay::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr, ObExpr &rt_expr) const
{
UNUSED(op_cg_ctx);
UNUSED(raw_expr);
int ret = OB_SUCCESS;
if (rt_expr.arg_cnt_ != 2) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("next_day expr should have 2 params", K(ret), K(rt_expr.arg_cnt_));
} else if (OB_ISNULL(rt_expr.args_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("children of next_day expr is null", K(ret), K(rt_expr.args_));
} else if (OB_ISNULL(rt_expr.args_[0]) ||
OB_ISNULL(rt_expr.args_[1])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("child of next_day expr is null", K(ret), K(rt_expr.args_[0]), K(rt_expr.args_[1]));
} else {
rt_expr.eval_func_ = ObExprNextDay::calc_next_day;
}
return ret;
}
int ObExprNextDay::calc_next_day(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
{
int ret = OB_SUCCESS;
ObDatum *param1 = NULL;
ObDatum *param2 = NULL;
if (OB_FAIL(expr.args_[0]->eval(ctx, param1))) {
LOG_WARN("eval first param value failed");
} else if (param1->is_null()) { //短路计算
expr_datum.set_null();
} else if (OB_FAIL(expr.args_[1]->eval(ctx, param2))) {
LOG_WARN("eval second param value failed");
} else if (param2->is_null()) {
expr_datum.set_null();
} else {
int64_t ori_date_utc = param1->get_datetime();
ObString wday_name = param2->get_string();
int64_t res_date_utc = 0;
if (OB_FAIL(ObTimeConverter::calc_next_date_of_the_wday(ori_date_utc,
wday_name.trim(), res_date_utc))) {
LOG_WARN("fail to calc next mday", K(ret));
} else {
expr_datum.set_datetime(res_date_utc);
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink