/**
 * 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.
 * This file is for implement of func json expr helper
 */

#define USING_LOG_PREFIX SQL_ENG
#include "lib/ob_errno.h"
#include "sql/engine/expr/ob_expr_cast.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/expr/ob_datum_cast.h"
#include "ob_expr_json_func_helper.h"
#include "lib/encode/ob_base64_encode.h" // for ObBase64Encoder
#include "lib/utility/ob_fast_convert.h" // ObFastFormatInt::format_unsigned
#include "lib/charset/ob_dtoa.h" // ob_gcvt_opt
#include "rpc/obmysql/ob_mysql_global.h" // DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE

using namespace oceanbase::common;
using namespace oceanbase::sql;

namespace oceanbase
{
namespace sql
{
static OB_INLINE int common_construct_otimestamp(const ObObjType type,
                                                 const ObDatum &in_datum,
                                                 ObOTimestampData &out_val)
{
  int ret = OB_SUCCESS;
  if (ObTimestampTZType == type) {
    out_val = in_datum.get_otimestamp_tz();
  } else if (ObTimestampLTZType == type || ObTimestampNanoType == type) {
    out_val = in_datum.get_otimestamp_tiny();
  } else {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid in type", K(ret), K(type));
  }
  return ret;
}

template <typename T>
int get_otimestamp_from_datum(const T &datum, ObOTimestampData &in_val, ObObjType type);
template <>
int get_otimestamp_from_datum<ObDatum>(const ObDatum &datum, ObOTimestampData &in_val, ObObjType type)
{
  INIT_SUCC(ret);
  if (ObTimestampTZType == type) {
    in_val = datum.get_otimestamp_tz();
  } else if (ObTimestampLTZType == type || ObTimestampNanoType == type) {
    in_val = datum.get_otimestamp_tiny();
  } else {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid in type", K(ret), K(type));
  }
  return ret;
}
template <>
int get_otimestamp_from_datum<ObObj>(const ObObj &datum, ObOTimestampData &in_val, ObObjType type)
{
  INIT_SUCC(ret);
  in_val = datum.get_otimestamp_value();
  return ret;
}

ObJsonInType ObJsonExprHelper::get_json_internal_type(ObObjType type)
{
  return type == ObJsonType ? ObJsonInType::JSON_BIN : ObJsonInType::JSON_TREE;
}

int ObJsonExprHelper::ensure_collation(ObObjType type, ObCollationType cs_type)
{
  INIT_SUCC(ret);
  if (ob_is_string_type(type) && (ObCharset::charset_type_by_coll(cs_type) != CHARSET_UTF8MB4)) {
    LOG_WARN("unsuport json string type with binary charset", K(type), K(cs_type));
    ret = OB_ERR_INVALID_JSON_CHARSET;
    LOG_USER_ERROR(OB_ERR_INVALID_JSON_CHARSET);
  }

  return ret;
}

int ObJsonExprHelper::get_json_or_str_data(ObExpr *expr, ObEvalCtx &ctx,
                                           common::ObArenaAllocator &allocator,
                                           ObString& str, bool& is_null)
{
  INIT_SUCC(ret);
  ObDatum *json_datum = NULL;
  ObObjType val_type = expr->datum_meta_.type_;
  if (OB_UNLIKELY(OB_FAIL(expr->eval(ctx, json_datum)))) {
    LOG_WARN("eval json arg failed", K(ret));
  } else if (json_datum->is_null() || val_type == ObNullType) {
    is_null = true;
  } else if (!ob_is_extend(val_type)
              && !ob_is_json(val_type)
              && !ob_is_raw(val_type)
              && !ob_is_string_type(val_type)) {
    ret = OB_ERR_INVALID_TYPE_FOR_OP;
    LOG_WARN("input type error", K(val_type));
  } else if (OB_FAIL(ObTextStringHelper::read_real_string_data(allocator, *json_datum,
                expr->datum_meta_, expr->obj_meta_.has_lob_header(), str))) {
    LOG_WARN("fail to get real data.", K(ret), K(str));
  }
  return ret;
}
int ObJsonExprHelper::get_json_doc(const ObExpr &expr, ObEvalCtx &ctx,
                                   common::ObArenaAllocator &allocator,
                                   uint16_t index, ObIJsonBase*& j_base,
                                   bool &is_null, bool need_to_tree, bool relax)
{
  INIT_SUCC(ret);
  ObDatum *json_datum = NULL;
  ObExpr *json_arg = expr.args_[index];
  ObObjType val_type = json_arg->datum_meta_.type_;
  ObCollationType cs_type = json_arg->datum_meta_.cs_type_;

  bool is_oracle = lib::is_oracle_mode();

  if (OB_UNLIKELY(OB_FAIL(json_arg->eval(ctx, json_datum)))) {
    LOG_WARN("eval json arg failed", K(ret));
  } else if (val_type == ObNullType || json_datum->is_null()) {
    is_null = true;
  } else if (val_type != ObJsonType && !ob_is_string_type(val_type)) {
    ret = OB_ERR_INVALID_TYPE_FOR_OP;
    LOG_WARN("input type error", K(val_type));
  } else if (lib::is_mysql_mode() && OB_FAIL(ObJsonExprHelper::ensure_collation(val_type, cs_type))) {
    LOG_WARN("fail to ensure collation", K(ret), K(val_type), K(cs_type));
  } else {
    ObString j_str;
    if (OB_FAIL(get_json_or_str_data(json_arg, ctx, allocator, j_str, is_null))) {
      LOG_WARN("fail to get real data.", K(ret), K(j_str));
    } else if (is_null) {
    } else {
      ObJsonInType j_in_type = ObJsonExprHelper::get_json_internal_type(val_type);
      ObJsonInType expect_type = need_to_tree ? ObJsonInType::JSON_TREE : j_in_type;
      bool relax_json = (lib::is_oracle_mode() && relax);
      uint32_t parse_flag = relax_json ? ObJsonParser::JSN_RELAXED_FLAG : 0;
      if (is_oracle && j_str.length() == 0) {
        is_null = true;
      } else if (OB_FAIL(ObJsonBaseFactory::get_json_base(&allocator, j_str, j_in_type,
                                                  expect_type, j_base, parse_flag))) {
        LOG_WARN("fail to get json base", K(ret), K(j_in_type));
        if (is_oracle) {
          ret = OB_ERR_JSON_SYNTAX_ERROR;
        } else {
          ret = OB_ERR_INVALID_JSON_TEXT_IN_PARAM;
          LOG_USER_ERROR(OB_ERR_INVALID_JSON_TEXT_IN_PARAM);
        }
      }
    }
  }
  return ret;
}


int ObJsonExprHelper::get_json_val(const common::ObObj &data, ObExprCtx &ctx,
                                   bool is_bool, common::ObIAllocator *allocator,
                                   ObIJsonBase*& j_base, bool to_bin)
{
  INIT_SUCC(ret);
  ObObjType val_type = data.get_type();
  if (data.is_null()) {
    void *json_node_buf = allocator->alloc(sizeof(ObJsonNull));
    if (OB_ISNULL(json_node_buf)) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    } else {
      ObJsonNull *null_node = static_cast<ObJsonNull*>(new(json_node_buf) ObJsonNull());
      if (to_bin) {
        if (OB_FAIL(ObJsonBaseFactory::transform(allocator, null_node, ObJsonInType::JSON_BIN, j_base))) {
          LOG_WARN("failed: json tree to bin", K(ret));
        }
      } else {
        j_base = null_node;
      }
    }
  } else if (is_bool) {
    void *json_node_buf = allocator->alloc(sizeof(ObJsonBoolean));
    if (OB_ISNULL(json_node_buf)) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    } else {
      ObJsonBoolean *bool_node = (ObJsonBoolean*)new(json_node_buf)ObJsonBoolean(data.get_bool());
      if (to_bin) {
        if (OB_FAIL(ObJsonBaseFactory::transform(allocator, bool_node, ObJsonInType::JSON_BIN, j_base))) {
          LOG_WARN("failed: json tree to bin", K(ret));
        }
      } else {
        j_base = bool_node;
      }
    }
  } else if (ObJsonExprHelper::is_convertible_to_json(val_type)) {
    ObCollationType cs_type = data.get_collation_type();
    if (OB_FAIL(ObJsonExprHelper::transform_convertible_2jsonBase(data, val_type, allocator,
                                                                  cs_type, j_base, to_bin,
                                                                  data.has_lob_header(), false))) {
      LOG_WARN("failed: parse value to jsonBase", K(ret), K(val_type));
    }
  } else {
    ObBasicSessionInfo *session = ctx.exec_ctx_->get_my_session();
    if (OB_ISNULL(session)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("session is NULL", K(ret));
    } else if (OB_FAIL(ObJsonExprHelper::transform_scalar_2jsonBase(data, val_type,
                                                                    allocator, data.get_scale(),
                                                                    session->get_timezone_info(),
                                                                    session,
                                                                    j_base, to_bin))) {
        LOG_WARN("failed: parse value to jsonBase", K(ret), K(val_type));
    }
  }

  return ret;
}

int ObJsonExprHelper::cast_to_json_tree(ObString &text, common::ObIAllocator *allocator, uint32_t parse_flag)
{
  INIT_SUCC(ret);
  ObJsonNode *j_tree = NULL;
  if (OB_FAIL(ObJsonParser::get_tree(allocator, text, j_tree, parse_flag))) {
    LOG_WARN("get json tree fail", K(ret));
  } else {
    ObJsonBuffer jbuf(allocator);
    if (OB_FAIL(j_tree->print(jbuf, true, false, 0))) {
      LOG_WARN("json binary to string failed", K(ret));
    } else if (jbuf.empty()) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("allocate memory for result failed", K(ret));
    } else {
      text.assign_ptr(jbuf.ptr(), jbuf.length());
    }
  }
  return ret;
}

int ObJsonExprHelper::get_json_val(const ObExpr &expr, ObEvalCtx &ctx,
                                   common::ObIAllocator *allocator, uint16_t index,
                                   ObIJsonBase*& j_base, bool to_bin, bool format_json,
                                   uint32_t parse_flag)
{
  INIT_SUCC(ret);
  ObDatum *json_datum = NULL;
  ObExpr *json_arg = expr.args_[index];
  ObObjType val_type = json_arg->datum_meta_.type_;
  if (OB_UNLIKELY(OB_FAIL(json_arg->eval(ctx, json_datum)))) {
    LOG_WARN("eval json arg failed", K(ret), K(val_type));
  } else if (json_datum->is_null()) {
    void *json_node_buf = allocator->alloc(sizeof(ObJsonNull));
    if (OB_ISNULL(json_node_buf)) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    } else {
      ObJsonNull *null_node = static_cast<ObJsonNull*>(new(json_node_buf) ObJsonNull());
      if (to_bin) {
        if (OB_FAIL(ObJsonBaseFactory::transform(allocator, null_node, ObJsonInType::JSON_BIN, j_base))) {
          LOG_WARN("failed: json tree to bin", K(ret));
        }
      } else {
        j_base = null_node;
      }
    }  
  } else if (json_arg->is_boolean_ == 1) {
    void *json_node_buf = allocator->alloc(sizeof(ObJsonBoolean));
    if (OB_ISNULL(json_node_buf)) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    } else {
      ObJsonBoolean *bool_node = (ObJsonBoolean*)new(json_node_buf)ObJsonBoolean(json_datum->get_bool());
      if (to_bin) {
        if (OB_FAIL(ObJsonBaseFactory::transform(allocator, bool_node, ObJsonInType::JSON_BIN, j_base))) {
          LOG_WARN("failed: json tree to bin", K(ret));
        }
      } else {
        j_base = bool_node;
      }
    }
  } else if (ObJsonExprHelper::is_convertible_to_json(val_type)) {
    ObCollationType cs_type = json_arg->datum_meta_.cs_type_;
    if (OB_FAIL(ObJsonExprHelper::transform_convertible_2jsonBase(*json_datum, val_type,
                                                                  allocator, cs_type,
                                                                  j_base, to_bin,
                                                                  json_arg->obj_meta_.has_lob_header(),
                                                                  false,
                                                                  HAS_FLAG(parse_flag, ObJsonParser::JSN_RELAXED_FLAG),
                                                                  format_json))) {
      LOG_WARN("failed: parse value to jsonBase", K(ret), K(val_type));
    }
  } else {
    ObBasicSessionInfo *session = ctx.exec_ctx_.get_my_session();
    ObScale scale = json_arg->datum_meta_.scale_;
    scale = (val_type == ObBitType) ? json_arg->datum_meta_.length_semantics_ : scale;
    if (OB_ISNULL(session)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("session is NULL", K(ret));
    } else if (OB_FAIL(ObJsonExprHelper::transform_scalar_2jsonBase(*json_datum, val_type,
                                                                    allocator, scale,
                                                                    session->get_timezone_info(),
                                                                    session,
                                                                    j_base, to_bin))) {
      LOG_WARN("failed: parse value to jsonBase", K(ret), K(val_type));
    }
  }
  return ret;
}
int ObJsonExprHelper::eval_oracle_json_val(ObExpr *expr,
                                           ObEvalCtx &ctx,
                                           common::ObIAllocator *allocator,
                                           ObIJsonBase*& j_base,
                                           bool is_format_json,
                                           bool is_strict,
                                           bool is_bin)
{
  INIT_SUCC(ret);
  ObDatum *json_datum = nullptr;
  ObExpr *json_arg = expr;
  bool is_bool_data_type = json_arg->is_boolean_;

  if (OB_FAIL(json_arg->eval(ctx, json_datum))) {
    LOG_WARN("eval json arg failed", K(ret), K(json_arg->datum_meta_));
  } else if (OB_FAIL(oracle_datum2_json_val(json_datum,
                                            json_arg->obj_meta_,
                                            allocator,
                                            ctx.exec_ctx_.get_my_session(),
                                            j_base,
                                            is_bool_data_type,
                                            is_format_json,
                                            is_strict, is_bin))) {
    LOG_WARN("failed to wrapper json base", K(ret), K(json_arg->datum_meta_),
             K(is_format_json), K(is_strict), K(is_bin));
  }

  return ret;
}

int ObJsonExprHelper::oracle_datum2_json_val(const ObDatum *json_datum,
                                             ObObjMeta& data_meta,
                                             common::ObIAllocator *allocator,
                                             ObBasicSessionInfo *session,
                                             ObIJsonBase*& j_base,
                                             bool is_bool_data_type,
                                             bool is_format_json,
                                             bool is_strict,
                                             bool is_bin)
{
  INIT_SUCC(ret);
  ObObjType val_type = data_meta.get_type();
  ObCollationType cs_type = data_meta.get_collation_type();
  bool is_nchar = (val_type == ObNCharType || val_type == ObNVarchar2Type);
  bool is_raw_type = (val_type == ObRawType);

  if (json_datum->is_null() || ob_is_null(val_type)) {
    ObJsonNull *null_node = nullptr;
    if (OB_ISNULL(null_node = OB_NEWx(ObJsonNull, allocator))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    }
    j_base = null_node;
  } else if (is_bool_data_type) {
    ObJsonBoolean *bool_node = nullptr;
    if (OB_ISNULL(bool_node = OB_NEWx(ObJsonBoolean, allocator, (json_datum->get_bool())))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("failed: alloscate jsonboolean", K(ret));
    }
    j_base = bool_node;
  } else if (ObJsonExprHelper::is_convertible_to_json(val_type)) {
    if (val_type == ObVarcharType
        || val_type == ObCharType
        || val_type == ObTinyTextType
        || val_type == ObTextType
        || val_type == ObMediumTextType
        || val_type == ObLongTextType
        || is_raw_type
        || is_nchar) {

      uint32_t parse_flag = ObJsonParser::JSN_RELAXED_FLAG;
      ObString j_str = json_datum->get_string();
      if (OB_FAIL(ObTextStringHelper::read_real_string_data(
                    allocator, val_type, cs_type, data_meta.has_lob_header(), j_str))) {
        LOG_WARN("fail to get real data.", K(ret), K(j_str));
      } else if (cs_type != CS_TYPE_INVALID && cs_type != CS_TYPE_BINARY
        && OB_FAIL(ObExprUtil::convert_string_collation(j_str, cs_type, j_str, CS_TYPE_UTF8MB4_BIN, *allocator))) {
        LOG_WARN("fail to convert charset.", K(ret), K(j_str), K(cs_type));
      } else if (!is_format_json || is_raw_type) {
        if (is_raw_type) {
          ObObj tmp_result;
          ObObj obj;

          ObDatum tmp_datum = *json_datum;
          tmp_datum.set_string(j_str);
          ObCastCtx cast_ctx(allocator, nullptr, CM_NONE, CS_TYPE_INVALID);

          if (OB_FAIL(tmp_datum.to_obj(obj, data_meta))) {
            LOG_WARN("datum to obj fail", K(ret));
          } else if (OB_FAIL(ObHexUtils::rawtohex(obj, cast_ctx, tmp_result))) {
            LOG_WARN("fail to check json syntax", K(ret), K(data_meta));
          } else {
            j_str = tmp_result.get_string();
          }
        }
        ObJsonString* string_node = nullptr;
        if (OB_FAIL(ret)) {
        } else if (OB_ISNULL(string_node = OB_NEWx(ObJsonString, allocator, j_str.ptr(), j_str.length()))) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("failed: alloscate json string node", K(ret));
        } else {
          j_base = string_node;
        }
      } else {
        if (OB_FAIL(ObJsonParser::check_json_syntax(j_str, allocator, parse_flag))) {
          if (!is_strict) {
            ret = OB_SUCCESS;
            ObJsonString* string_node = nullptr;
            if (OB_ISNULL(string_node = OB_NEWx(ObJsonString, allocator, j_str.ptr(), j_str.length()))) {
              ret = OB_ALLOCATE_MEMORY_FAILED;
              LOG_WARN("failed: alloscate json string node", K(ret));
            }
            j_base = string_node;
          } else {
            ret = OB_ERR_JSON_SYNTAX_ERROR;
            LOG_WARN("fail to check json syntax", K(ret), K(j_str));
          }
        } else if (OB_FAIL(ObJsonBaseFactory::get_json_base( allocator, j_str,
                                   ObJsonInType::JSON_TREE, ObJsonInType::JSON_TREE, j_base, parse_flag))) {
          LOG_WARN("failed: parse json string node", K(ret), K(j_str));
        }
      }
    } else if (val_type == ObJsonType) {
      ObJsonInType to_type = is_bin ? ObJsonInType::JSON_BIN : ObJsonInType::JSON_TREE;
      ObString j_str = json_datum->get_string();
      if (OB_FAIL(ObTextStringHelper::read_real_string_data(
                    allocator, val_type, cs_type, data_meta.has_lob_header(), j_str))) {
        LOG_WARN("fail to get real data.", K(ret), K(j_str));
      } else if (OB_FAIL(ObJsonBaseFactory::get_json_base(allocator, j_str, ObJsonInType::JSON_BIN, to_type, j_base))) {
        ret = OB_ERR_INVALID_JSON_TEXT_IN_PARAM;
        LOG_WARN("fail to get json base", K(ret));
      }
    } else {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("Invalid argument", K(ret), K(val_type));
    }

    if (OB_SUCC(ret)) {

      if (OB_FAIL(ObJsonBaseFactory::transform(allocator, j_base,
                      is_bin ? ObJsonInType::JSON_BIN : ObJsonInType::JSON_TREE , j_base))) {
        LOG_WARN("failed: json tree to bin", K(ret));
      } else {
        j_base->set_allocator(allocator);
      }
    }
  } else {
    ObScale scale = data_meta.get_scale();
    if (is_format_json) {
      ret = OB_ERR_INVALID_TYPE_FOR_OP;
      LOG_WARN("input type error", K(val_type));
    } else if (OB_ISNULL(session)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("session is NULL", K(ret));
    } else if (val_type == ObIntervalDSType || val_type == ObIntervalYMType) {
      // internal json type not support interval type using string type instead
      int64_t len = 0;
      char* string_buf = nullptr;
      ObJsonString* string_node = nullptr;

      if (OB_ISNULL(string_buf = static_cast<char*>(allocator->alloc(OB_CAST_TO_VARCHAR_MAX_LENGTH)))) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("failed to allocate memory", K(ret));
      } else if (ob_is_interval_ym(val_type)) {
        ObIntervalYMValue in_val(json_datum->get_interval_nmonth());
        if (OB_FAIL(ObTimeConverter::interval_ym_to_str(
                      in_val, scale, string_buf, OB_CAST_TO_VARCHAR_MAX_LENGTH, len, true))) {
          LOG_WARN("interval_ym_to_str failed", K(ret));
        }
      } else {
        ObIntervalDSValue in_val(json_datum->get_interval_ds());
        if (OB_FAIL(ObTimeConverter::interval_ds_to_str(
                      in_val, scale, string_buf, OB_CAST_TO_VARCHAR_MAX_LENGTH, len, true))) {
          LOG_WARN("interval_ym_to_str failed", K(ret));
        }
      }

      if (OB_FAIL(ret)) {
      } else if (OB_ISNULL(string_node = OB_NEWx(ObJsonString, allocator, (const char*)string_buf, len))) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("failed to create json string node", K(ret));
      } else {
        j_base = string_node;
      }
    } else if (val_type == ObTimestampTZType || val_type == ObTimestampLTZType) {
      // internal json type not support time zone or local time zone type using string type instead
      char* string_buf = nullptr;
      int64_t len = 0;
      ObJsonString* string_node = nullptr;

      if (OB_ISNULL(string_buf = static_cast<char*>(allocator->alloc(OB_CAST_TO_VARCHAR_MAX_LENGTH)))) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("failed to allocate memory", K(ret));
      } else {
        ObOTimestampData in_val;
        ObScale scale = data_meta.get_scale();
        const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(session);
        if (OB_FAIL(common_construct_otimestamp(val_type, *json_datum, in_val))) {
          LOG_WARN("common_construct_otimestamp failed", K(ret));
        } else if (OB_FAIL(ObTimeConverter::otimestamp_to_str(in_val, dtc_params, scale,
                                                              val_type, string_buf, OB_CAST_TO_VARCHAR_MAX_LENGTH, len))) {
          LOG_WARN("failed to convert otimestamp to string", K(ret));
        } else if (OB_ISNULL(string_node = OB_NEWx(ObJsonString, allocator, (const char*)string_buf, len))) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("failed to create json string node", K(ret));
        } else {
          j_base = string_node;
        }
      }
    } else if (OB_FAIL(ObJsonExprHelper::transform_scalar_2jsonBase(*json_datum, val_type,
                                                                    allocator, scale,
                                                                    session->get_timezone_info(),
                                                                    session,
                                                                    j_base,
                                                                    is_bin))) {
      LOG_WARN("failed: parse value to jsonBase", K(ret), K(val_type));
    }
  }
  return ret;
}

int ObJsonExprHelper::json_base_replace(ObIJsonBase *json_old, ObIJsonBase *json_new,
                                        ObIJsonBase *&json_doc)
{
  INIT_SUCC(ret);
  if (json_old == json_doc) {
    json_doc = json_new;
  } else {
    ObIJsonBase *json_old_tree = json_old;
    ObIAllocator *allocator = json_doc->get_allocator();
    if (!json_old->is_tree() &&
        ObJsonBaseFactory::transform(allocator, json_old, ObJsonInType::JSON_TREE, json_old_tree)) {
      LOG_WARN("fail to transform to tree", K(ret), K(*json_old));
    } else {
      ObIJsonBase *parent = static_cast<ObJsonNode *>(json_old_tree)->get_parent();
      if(OB_NOT_NULL(parent) && parent != json_doc) {
        if (OB_FAIL(parent->replace(json_old_tree, json_new))) {
          LOG_WARN("json base replace failed", K(ret));
        }
      } else {
        if (OB_FAIL(json_doc->replace(json_old_tree, json_new))) {
          LOG_WARN("json base replace failed", K(ret));
        }
      }
    }
  }
  return ret;
}

// get json expr path cache context, if not exists cache context do nothing
ObJsonPathCache* ObJsonExprHelper::get_path_cache_ctx(const uint64_t& id, ObExecContext *exec_ctx)
{
  INIT_SUCC(ret);
  ObJsonPathCacheCtx* cache_ctx = NULL;
  if (ObExpr::INVALID_EXP_CTX_ID != id) {
    cache_ctx = static_cast<ObJsonPathCacheCtx*>(exec_ctx->get_expr_op_ctx(id));
    if (OB_ISNULL(cache_ctx)) {
      // if pathcache not exist, create one
      void *cache_ctx_buf = NULL;
      ret = exec_ctx->create_expr_op_ctx(id, sizeof(ObJsonPathCacheCtx), cache_ctx_buf);
      if (OB_SUCC(ret) && OB_NOT_NULL(cache_ctx_buf)) {
        cache_ctx = new (cache_ctx_buf) ObJsonPathCacheCtx(&exec_ctx->get_allocator());
      }
    }
  }
  return (cache_ctx == NULL) ? NULL : cache_ctx->get_path_cache();
}

int ObJsonExprHelper::find_and_add_cache(ObJsonPathCache* path_cache, ObJsonPath*& res_path,
                                         ObString& path_str, int arg_idx, bool enable_wildcard)
{
  INIT_SUCC(ret);
  if (OB_FAIL(path_cache->find_and_add_cache(res_path, path_str, arg_idx))) {
    ret = OB_ERR_INVALID_JSON_PATH;
    LOG_USER_ERROR(OB_ERR_INVALID_JSON_PATH);
  } else if (!enable_wildcard && res_path->can_match_many()) {
    ret = OB_ERR_INVALID_JSON_PATH_WILDCARD;
    LOG_USER_ERROR(OB_ERR_INVALID_JSON_PATH_WILDCARD);
  }
  return ret;
}

bool ObJsonExprHelper::is_convertible_to_json(ObObjType &type)
{
  bool val = false;
  switch (type) {
    case ObNullType:
    case ObJsonType:
    case ObVarcharType:
    case ObCharType:
    case ObTinyTextType:
    case ObTextType:
    case ObMediumTextType:
    case ObLobType:
    case ObRawType:
    case ObLongTextType: {
      val = true;
      break;
    }
    default:
      break;
  }
  if (lib::is_oracle_mode()) {
    switch (type) {
      case ObNVarchar2Type:
      case ObNCharType: {
        val = true;
        break;
      }
      default:
        break;
    }
  }
  return val;
}

int ObJsonExprHelper::is_valid_for_json(ObExprResType* types_stack,
                                        uint32_t index,
                                        const char* func_name)
{
  INIT_SUCC(ret);
  ObObjType in_type = types_stack[index].get_type();

  if (!is_convertible_to_json(in_type)) {
    ret = OB_ERR_INVALID_TYPE_FOR_JSON;
    LOG_USER_ERROR(OB_ERR_INVALID_TYPE_FOR_JSON, index + 1, func_name);
  } else if (ob_is_string_type(in_type)) {
    if (types_stack[index].get_collation_type() == CS_TYPE_BINARY) {
      types_stack[index].set_calc_collation_type(CS_TYPE_BINARY);
    } else {
      if (types_stack[index].get_charset_type() != CHARSET_UTF8MB4) {
        types_stack[index].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
      }
    }
  }

  return ret;
}

int ObJsonExprHelper::is_valid_for_json(ObExprResType& type,
                                        uint32_t index,
                                        const char* func_name)
{
  INIT_SUCC(ret);
  ObObjType in_type = type.get_type();
  
  if (!is_convertible_to_json(in_type)) {
    ret = OB_ERR_INVALID_TYPE_FOR_JSON;
    LOG_USER_ERROR(OB_ERR_INVALID_TYPE_FOR_JSON, index, func_name);
  } else if (ob_is_string_type(in_type) && type.get_collation_type() != CS_TYPE_BINARY) {
    if (type.get_charset_type() != CHARSET_UTF8MB4) {
      type.set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
    }
  }

  return ret;
}

int ObJsonExprHelper::is_valid_for_path(ObExprResType* types_stack, uint32_t index)
{
  INIT_SUCC(ret);
  ObObjType in_type = types_stack[index].get_type();
  if (in_type == ObNullType || in_type == ObJsonType) {
  } else if (ob_is_string_type(in_type)) {
    if (types_stack[index].get_charset_type() != CHARSET_UTF8MB4) {
      types_stack[index].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
    }
  } else {
    ret = OB_ERR_INVALID_JSON_PATH;
    LOG_USER_ERROR(OB_ERR_INVALID_JSON_PATH);
  }
  return ret;
}

void ObJsonExprHelper::set_type_for_value(ObExprResType* types_stack, uint32_t index)
{
  ObObjType in_type = types_stack[index].get_type();
  if (in_type == ObNullType) {
  } else if (ob_is_string_type(in_type)) {
    if (types_stack[index].get_charset_type() != CHARSET_UTF8MB4) {
      types_stack[index].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
    }
  } else if  (in_type == ObJsonType) {
    types_stack[index].set_calc_collation_type(CS_TYPE_UTF8MB4_BIN);
  }
}

int ObJsonExprHelper::is_json_zero(const ObString& data, int& result)
{
  INIT_SUCC(ret);
  int tmp_result = 0;
  ObJsonBin j_bin(data.ptr(), data.length());
  if (data.length() == 0) {
    result = 1; 
  } else if (OB_FAIL(j_bin.reset_iter())) {
    LOG_WARN("failed: reset iter", K(ret));
  } else if (OB_FAIL(ObJsonBaseUtil::compare_int_json(0, &j_bin, tmp_result))) {
    LOG_WARN("failed: cmp json", K(ret));
  } else {
    result = (tmp_result == 0) ? 0 : 1;
  }
  return ret;
}

template <typename T>
int ObJsonExprHelper::transform_scalar_2jsonBase(const T &datum,
                                                 ObObjType type,
                                                 common::ObIAllocator *allocator,
                                                 ObScale scale,
                                                 const ObTimeZoneInfo *tz_info,
                                                 ObBasicSessionInfo *session,
                                                 ObIJsonBase*& j_base,
                                                 bool to_bin)
{
  int ret = OB_SUCCESS;
  void* buf = NULL;
  ObIJsonBase* json_node = NULL;

  switch(type) {
    case ObTinyIntType: {
      // mysql boolean type 
      buf = allocator->alloc(sizeof(ObJsonInt));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("buf allocate failed", K(ret), K(type));
      } else {
        json_node = (ObJsonInt*)new(buf)ObJsonInt(datum.get_int());
      }
      break;
    }
    case ObSmallIntType:
    case ObMediumIntType:
    case ObInt32Type:
    case ObIntType: {
      buf = allocator->alloc(sizeof(ObJsonInt));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("buf allocate failed", K(ret), K(type));
      } else {
        json_node = (ObJsonInt*)new(buf)ObJsonInt(datum.get_int());
      }
      break;
    }
    case ObUTinyIntType:
    case ObUSmallIntType:
    case ObUMediumIntType:
    case ObUInt32Type:
    case ObUInt64Type:
    case ObYearType: {
      buf = allocator->alloc(sizeof(ObJsonUint));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("buf allocate failed", K(ret), K(type));
      } else {
        json_node = (ObJsonInt*)new(buf)ObJsonUint(datum.get_uint64());
      }
      break;
    }
    case ObDateTimeType:
    case ObTimestampType:
    case ObTimestampNanoType:
    case ObDateType:
    case ObTimeType: {
      ObTime ob_time;
      int64_t value = 0;
      ObJsonNodeType node_type;
      if (type == ObDateType) {
        node_type = ObJsonNodeType::J_DATE;
        value = datum.get_date();
        ob_time.mode_ = DT_TYPE_DATE;
        if (OB_FAIL(ObTimeConverter::date_to_ob_time(value, ob_time))) {
          LOG_WARN("date transform to ob time failed", K(ret), K(value));
        }
      } else if (type == ObTimeType) {
        node_type = ObJsonNodeType::J_TIME;
        value = datum.get_time();
        ob_time.mode_ = DT_TYPE_TIME;
        if (OB_FAIL(ObTimeConverter::time_to_ob_time(value, ob_time))) {
          LOG_WARN("time transform to ob time failed", K(ret), K(value));
        }
      } else if (type == ObDateTimeType) {
        node_type = ObJsonNodeType::J_DATETIME;
        value = datum.get_datetime();
        ob_time.mode_ = DT_TYPE_DATETIME;
        if (OB_FAIL(ObTimeConverter::datetime_to_ob_time(value, tz_info, ob_time))) {
          LOG_WARN("datetime transform to ob time failed", K(ret), K(value));
        }
      } else {
        node_type = ObJsonNodeType::J_TIMESTAMP;
        if (lib::is_oracle_mode()) {
          ObOTimestampData in_val;
          char buf[OB_CAST_TO_VARCHAR_MAX_LENGTH] = {0};
          int64_t len = 0;
          if (OB_ISNULL(session)) {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("session is NULL", K(ret));
          } else {
            const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(session);
            if (OB_FAIL(get_otimestamp_from_datum(datum, in_val, type))) {
              LOG_WARN("get otimestamp fail", K(ret));
            } else if (OB_SUCC(ret) && OB_FAIL(ObTimeConverter::otimestamp_to_ob_time(type, in_val, NULL, ob_time))) {
              LOG_WARN("fail to convert otimestamp to ob_time", K(ret), K(in_val));
            }
          }
        } else {
          value = datum.get_timestamp();
          ob_time.mode_ = DT_TYPE_DATETIME;
          if (OB_FAIL(ObTimeConverter::datetime_to_ob_time(value, tz_info, ob_time))) {
            LOG_WARN("default transform : datetime to ob time failed", K(ret), K(value));
          }
        }
      }

      if (OB_SUCC(ret)) {
        buf = allocator->alloc(sizeof(ObJsonDatetime));
        if (OB_ISNULL(buf)) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("buf allocate failed", K(ret));
        } else {
          json_node = (ObJsonDatetime *)new(buf)ObJsonDatetime(node_type, ob_time);
        }
      }
      break;
    }

    case ObFloatType:
    case ObDoubleType:
    case ObUFloatType:
    case ObUDoubleType: {
      double val;
      if (type == ObFloatType || type ==ObUFloatType ) {
        val = datum.get_float();
      } else {
        val = datum.get_double();
      }
      if (isnan(val)) {
        buf = allocator->alloc(sizeof(ObJsonString));
        if (OB_ISNULL(buf)) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("buf allocate failed", K(ret), K(type));
        } else {
          json_node = (ObJsonString *)new(buf)ObJsonString("Nan", 3);
        }
      } else if (isinf(val) != 0) {
        buf = allocator->alloc(sizeof(ObJsonString));
        if (OB_ISNULL(buf)) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("buf allocate failed", K(ret), K(type));
        } else {
          if (isinf(val) == 1) {
            json_node = (ObJsonString *)new(buf)ObJsonString("Inf", 3);
          } else {
            json_node = (ObJsonString *)new(buf)ObJsonString("-Inf", 4);
          }
        }
      } else {
        buf = allocator->alloc(sizeof(ObJsonDouble));
        if (OB_ISNULL(buf)) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("buf allocate failed", K(ret), K(type));
        } else {
          json_node = (ObJsonDouble *)new(buf)ObJsonDouble(val);
        }
      }
      break;
    }

    case ObUNumberType:
    case ObNumberFloatType:
    case ObNumberType: {
      // won't waster much memory, do deep copy num
      number::ObNumber num;
      buf = allocator->alloc(sizeof(ObJsonDecimal));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("buf allocate failed", K(ret), K(type));
      } else if (OB_FAIL(num.deep_copy_v3(datum.get_number(), *allocator))) {
        LOG_WARN("num deep copy failed", K(ret), K(type));
      } else {
        // shadow copy
        json_node = (ObJsonDecimal *)new(buf)ObJsonDecimal(num, -1, scale);
      }
      break;
    }
    case ObHexStringType: {
      buf = allocator->alloc(sizeof(ObJsonOpaque));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
        LOG_WARN("buf allocate failed", K(ret), K(type));
      } else {
        json_node = (ObJsonOpaque *)new(buf)ObJsonOpaque(datum.get_string(), type);
      }
      break;
    }
    default:
    {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("Invalid argument", K(ret), K(type));
    }
  }

  if (OB_SUCC(ret)) {
    if (to_bin) {
      if (OB_FAIL(ObJsonBaseFactory::transform(allocator, json_node, ObJsonInType::JSON_BIN, j_base))) {
        LOG_WARN("failed: json tree to bin", K(ret));
      }
    } else {
      j_base = json_node;
    }
  }

  return ret;
}

#define PRINT_OB_DATETIME(ob_time, value, j_buf) \
  const int64_t tmp_buf_len = DATETIME_MAX_LENGTH + 1; \
  char tmp_buf[tmp_buf_len] = {0}; \
  int64_t pos = 0; \
  const int16_t print_scale = 6; \
  if (OB_FAIL(j_buf.append("\""))) { \
    LOG_WARN("fail to append \"", K(ret)); \
  } else if (OB_FAIL(ObTimeConverter::datetime_to_ob_time(value, tz_info, ob_time))) { \
  } else if (OB_FAIL(ObTimeConverter::ob_time_to_str(ob_time, ob_time.mode_, print_scale,  \
                                                      tmp_buf, tmp_buf_len, pos, true))) { \
    LOG_WARN("fail to change time to string", K(ret), K(ob_time), K(pos)); \
  } else if (OB_FAIL(j_buf.append(tmp_buf))) { \
    LOG_WARN("fail to append date_buf to j_buf", K(ret), KCSTRING(tmp_buf)); \
  } else if (OB_FAIL(j_buf.append("\""))) { \
    LOG_WARN("fail to append \"", K(ret)); \
  }

#define PRINT_OB_TIME(ob_time, value, TO_OB_TIME_METHOD, j_buf) \
  const int64_t tmp_buf_len = DATETIME_MAX_LENGTH + 1; \
  char tmp_buf[tmp_buf_len] = {0}; \
  int64_t pos = 0; \
  const int16_t print_scale = 6; \
  if (OB_FAIL(j_buf.append("\""))) { \
    LOG_WARN("fail to append \"", K(ret)); \
  } else if (OB_FAIL(ObTimeConverter::TO_OB_TIME_METHOD(value, ob_time))) { \
  } else if (OB_FAIL(ObTimeConverter::ob_time_to_str(ob_time, ob_time.mode_, print_scale,  \
                                                      tmp_buf, tmp_buf_len, pos, true))) { \
    LOG_WARN("fail to change time to string", K(ret), K(ob_time), K(pos)); \
  } else if (OB_FAIL(j_buf.append(tmp_buf))) { \
    LOG_WARN("fail to append date_buf to j_buf", K(ret), KCSTRING(tmp_buf)); \
  } else if (OB_FAIL(j_buf.append("\""))) { \
    LOG_WARN("fail to append \"", K(ret)); \
  }

struct ObFindDoubleEscapeFunc {
  ObFindDoubleEscapeFunc() {}

  bool operator()(const char c)
  {
    return c == '.' || c == 'e';
  }
};

int ObJsonExprHelper::get_timestamp_str_in_oracle_mode(ObEvalCtx &ctx,
                                                        const ObDatum &datum,
                                                        ObObjType type,
                                                        ObScale scale,
                                                        const ObTimeZoneInfo *tz_info,
                                                        ObJsonBuffer &j_buf)
{
  INIT_SUCC(ret);
  ObOTimestampData in_val;
  char buf[OB_CAST_TO_VARCHAR_MAX_LENGTH] = {0};
  int64_t len = 0;
  ObBasicSessionInfo *session = ctx.exec_ctx_.get_my_session();
  if (OB_ISNULL(session)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session is NULL", K(ret));
  } else {
    const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(session);
    if (OB_FAIL(common_construct_otimestamp(type, datum, in_val))) {
      LOG_WARN("common_construct_otimestamp failed", K(ret));
    } else if (OB_FAIL(ObTimeConverter::otimestamp_to_str(in_val,
                                                  dtc_params,
                                                  scale, type, buf,
                                                  OB_CAST_TO_VARCHAR_MAX_LENGTH,
                                                  len))) {
      LOG_WARN("failed to convert otimestamp to string", K(ret));
    } else {
      ObString in_str(sizeof(buf), static_cast<int32_t>(len), buf);
      if (OB_FAIL(j_buf.append("\""))) {
        LOG_WARN("fail to append \"", K(ret));
      } else if (OB_FAIL(j_buf.append(in_str))) {
        LOG_WARN("fail to append date_buf to j_buf", K(ret), K(in_str));
      } else if (OB_FAIL(j_buf.append("\""))) {
        LOG_WARN("fail to append \"", K(ret));
      }
    }
  }
  return ret;
}

bool ObJsonExprHelper::is_cs_type_bin(ObCollationType &cs_type)
{
  bool res = false;
  switch(cs_type){
    case CS_TYPE_BINARY : {
      res = true;
      break;
    }
    default : {
      break;
    }
  }
  return res;
}

template <typename T>
int ObJsonExprHelper::transform_convertible_2jsonBase(const T &datum,
                                                      ObObjType type,
                                                      common::ObIAllocator *allocator,
                                                      ObCollationType cs_type,
                                                      ObIJsonBase*& j_base,
                                                      bool to_bin,
                                                      bool has_lob_header,
                                                      bool deep_copy,
                                                      bool relax_type,
                                                      bool format_json)
{
  int ret = OB_SUCCESS;
  void* buf = NULL;
  ObIJsonBase* json_node = NULL;

  switch(type) {
    case ObNullType: {
      buf = allocator->alloc(sizeof(ObJsonNull));
      if (OB_ISNULL(buf)) {
        ret = OB_ALLOCATE_MEMORY_FAILED;
      } else {
        json_node = (ObJsonNull*)new(buf)ObJsonNull();
      }
      break;
    }
    case ObVarcharType:
    case ObCharType:
    case ObTinyTextType:
    case ObTextType :
    case ObMediumTextType:
    case ObLongTextType: {
      ObString j_str;
      if (is_mysql_mode()
          && OB_FAIL(ObJsonExprHelper::ensure_collation(type, cs_type))) {
        // should check collation first
        LOG_WARN("Invalid collation type for input string.", K(ret));
      } else {
        j_str = datum.get_string();
        if (OB_FAIL(ObTextStringHelper::read_real_string_data(allocator, type, cs_type, has_lob_header, j_str))) {
          LOG_WARN("fail to get real data.", K(ret), K(j_str));
        } else if (deep_copy) {
          ret = deep_copy_ob_string(*allocator, j_str, j_str);
        }
      }

      if (OB_SUCC(ret)) {
        if (format_json) {
          uint32_t parse_flag = relax_type ? ObJsonParser::JSN_RELAXED_FLAG : ObJsonParser::JSN_STRICT_FLAG;
          if(OB_FAIL(ObJsonExprHelper::cast_to_json_tree(j_str, allocator, parse_flag))) {
            LOG_WARN("cast to json tree fail", K(ret));
          } else {
            ObJsonInType to_type = to_bin ? ObJsonInType::JSON_BIN : ObJsonInType::JSON_TREE;
            if (OB_FAIL(ObJsonBaseFactory::get_json_base(allocator, j_str, ObJsonInType::JSON_TREE,
                                                        to_type, json_node, parse_flag))) {
              ret = OB_ERR_INVALID_JSON_TEXT_IN_PARAM;
              LOG_WARN("fail to get json base", K(ret), K(j_str));
            }
          }
        } else {
          uint64_t len = j_str.length();
          const char *ptr = j_str.ptr();
          buf = allocator->alloc(sizeof(ObJsonString));
          if (OB_ISNULL(buf)) {
            ret = OB_ALLOCATE_MEMORY_FAILED;
          } else {
            json_node = (ObJsonString*)new(buf)ObJsonString(ptr, len);
          }
        }
      }

      break;
    }
    case ObJsonType: {
      ObString j_str = datum.get_string();
      if (OB_SUCC(ret)) {
        ObString tmp_str = j_str;
        if (OB_FAIL(ObTextStringHelper::read_real_string_data(allocator, type, cs_type, has_lob_header, tmp_str))) {
          LOG_WARN("fail to get real data.", K(ret), K(j_str));
        } else if (deep_copy) {
          if (OB_FAIL(deep_copy_ob_string(*allocator, tmp_str, j_str))) {
            LOG_WARN("do deep copy failed", K(ret));
          }
        } else {
          j_str = tmp_str;
        }
      }

      if (OB_SUCC(ret)) {
        ObJsonInType to_type = to_bin ? ObJsonInType::JSON_BIN : ObJsonInType::JSON_TREE;
        uint32_t parse_flag = relax_type ? ObJsonParser::JSN_RELAXED_FLAG : ObJsonParser::JSN_STRICT_FLAG;
        if (OB_FAIL(ObJsonBaseFactory::get_json_base(allocator, j_str, ObJsonInType::JSON_BIN,
                                                     to_type, json_node, parse_flag))) {
          ret = OB_ERR_INVALID_JSON_TEXT_IN_PARAM;
          LOG_WARN("fail to get json base", K(ret));
        }
      }
      break;
    }
    default:
    {
      ret = OB_INVALID_ARGUMENT;
      LOG_WARN("Invalid argument", K(ret), K(type));
    }
  }

  if (OB_SUCC(ret)) {
    if (to_bin) {
      if (OB_FAIL(ObJsonBaseFactory::transform(allocator, json_node, ObJsonInType::JSON_BIN, j_base))) {
        LOG_WARN("failed: json tree to bin", K(ret));
      }
    } else {
      json_node->set_allocator(allocator);
      j_base = json_node;
    }
  }

  return ret;
}

int ObJsonExprHelper::get_cast_type(const ObExprResType param_type2,
                                    ObExprResType &dst_type)
{
  INIT_SUCC(ret);
  if (!param_type2.is_int() && !param_type2.get_param().is_int()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("cast param type is unexpected", K(param_type2));
  } else {
    const ObObj &param = param_type2.get_param();
    ParseNode parse_node;
    ObObjType obj_type;
    parse_node.value_ = param.get_int();
    obj_type = static_cast<ObObjType>(parse_node.int16_values_[OB_NODE_CAST_TYPE_IDX]);
    ObCollationType collation_type = static_cast<ObCollationType>(parse_node.int16_values_[OB_NODE_CAST_COLL_IDX]);

    dst_type.set_collation_type(collation_type);
    dst_type.set_type(obj_type);
    if (ob_is_string_type(obj_type) || ob_is_lob_locator(obj_type)) {
      // cast(x as char(10)) or cast(x as binary(10))
      dst_type.set_full_length(parse_node.int32_values_[OB_NODE_CAST_C_LEN_IDX],
                               param_type2.get_accuracy().get_length_semantics());
      // if (collation_type != CS_TYPE_UTF8MB4_BIN && obj_type == ObLongTextType) {
      //   dst_type.set_collation_type(CS_TYPE_UTF8MB4_BIN);
      // }
    } else if (ObJsonType == dst_type.get_type()) {
      dst_type.set_collation_type(CS_TYPE_UTF8MB4_BIN);
    } else {
      dst_type.set_precision(parse_node.int16_values_[OB_NODE_CAST_N_PREC_IDX]);
      dst_type.set_scale(parse_node.int16_values_[OB_NODE_CAST_N_SCALE_IDX]);
    }
    LOG_DEBUG("get_cast_type", K(dst_type), K(param_type2));
  }
  return ret;
}

int ObJsonExprHelper::set_dest_type(ObExprResType &type1,
                                  ObExprResType &type,
                                  ObExprResType &dst_type,
                                  ObExprTypeCtx &type_ctx)
{
  INIT_SUCC(ret);
  const sql::ObSQLSessionInfo *session = type_ctx.get_session();
  if (OB_ISNULL(session)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("ptr is NULL", K(ret), KP(session));
  } else {
    // always cast to user requested type
    type.set_type(dst_type.get_type());
    type.set_collation_type(dst_type.get_collation_type());
    int16_t scale = dst_type.get_scale();
    if (OB_SUCC(ret)) {
      ObCollationType collation_connection = type_ctx.get_coll_type();
      ObCollationType collation_nation = session->get_nls_collation_nation();
      int32_t length = 0;
      if (ob_is_string_type(dst_type.get_type()) || ob_is_json(dst_type.get_type())) {
        type.set_collation_level(CS_LEVEL_IMPLICIT);
        int32_t len = dst_type.get_length();
        int16_t length_semantics = ((dst_type.is_string_type())
            ? dst_type.get_length_semantics()
            : (OB_NOT_NULL(type_ctx.get_session())
                ? type_ctx.get_session()->get_actual_nls_length_semantics()
                : LS_BYTE));
        if (len > 0) { // cast(1 as char(10))
          type.set_full_length(len, length_semantics);
        } else if (OB_FAIL(get_cast_string_len(type1, dst_type, type_ctx, len, length_semantics,
                                               collation_connection))) { // cast (1 as char)
          LOG_WARN("fail to get cast string length", K(ret));
        } else {
          type.set_full_length(len, length_semantics);
        }
        if (CS_TYPE_INVALID != dst_type.get_collation_type()) {
          // cast as binary
          type.set_collation_type(dst_type.get_collation_type());
        } else {
          // use collation of current session
          type.set_collation_type(ob_is_nstring_type(dst_type.get_type()) ?
                                  collation_nation : collation_connection);
        }
      } else {
        type.set_length(length);
        type.set_scale(dst_type.get_scale());
      }

      if (OB_SUCC(ret) && ob_is_json(dst_type.get_type())) {
        type.set_length((ObAccuracy::DDL_DEFAULT_ACCURACY[ObJsonType]).get_length());
      }
    }
  }
  return ret;
}

int ObJsonExprHelper::get_dest_type(const ObExpr &expr, int64_t pos,
                                    ObEvalCtx& ctx,
                                    ObObjType &dest_type, int32_t &dst_len)
{
  INIT_SUCC(ret);
  ParseNode node;
  ObDatum *dst_type_dat = NULL;
  if (OB_ISNULL(expr.args_) || OB_ISNULL(expr.args_[pos])) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("unexpected expr", K(ret), K(expr.arg_cnt_), KP(expr.args_));
  } else if (OB_FAIL(expr.args_[pos]->eval(ctx, dst_type_dat))) {
    LOG_WARN("eval dst type datum failed", K(ret));
  } else {
    node.value_ = dst_type_dat->get_int();
    dest_type = static_cast<ObObjType>(node.int16_values_[0]);
    dst_len = node.int32_values_[OB_NODE_CAST_C_LEN_IDX];
  }
  return ret;
}

int ObJsonExprHelper::get_cast_string_len(ObExprResType &type1,
                        ObExprResType &type2,
                        common::ObExprTypeCtx &type_ctx,
                        int32_t &res_len,
                        int16_t &length_semantics,
                        common::ObCollationType conn)
{
  INIT_SUCC(ret);
  const ObObj &val = type1.get_param();
  if (!type1.is_literal()) { // column
    res_len = CAST_STRING_DEFUALT_LENGTH[type1.get_type()];
    int16_t prec = type1.get_accuracy().get_precision();
    int16_t scale = type1.get_accuracy().get_scale();
    switch(type1.get_type()) {
    case ObTextType:
    case ObLongTextType:
    case ObVarcharType:
    case ObCharType: {
        res_len = type1.get_length();
        length_semantics = type1.get_length_semantics();
        break;
      }
    default: {
        break;
      }
    }
  } else if (type1.is_null()) {
    res_len = 0;//compatible with mysql;
  } else if (OB_ISNULL(type_ctx.get_session())) {
    // calc type don't set ret, just print the log. by design.
    LOG_WARN("my_session is null");
  } else { // literal
    ObArenaAllocator oballocator(ObModIds::BLOCK_ALLOC);
    ObCastMode cast_mode = CM_NONE;
    ObCollationType cast_coll_type = (CS_TYPE_INVALID != type2.get_collation_type())
        ? type2.get_collation_type()
        : conn;
    const ObDataTypeCastParams dtc_params =
          ObBasicSessionInfo::create_dtc_params(type_ctx.get_session());
    ObCastCtx cast_ctx(&oballocator,
                       &dtc_params,
                       0,
                       cast_mode,
                       cast_coll_type);
    ObString val_str;
    EXPR_GET_VARCHAR_V2(val, val_str);
    if (OB_SUCC(ret) && NULL != val_str.ptr()) {
      int32_t len_byte = val_str.length();
      res_len = len_byte;
      length_semantics = LS_CHAR;
      if (NULL != val_str.ptr()) {
        int32_t trunc_len_byte = static_cast<int32_t>(ObCharset::strlen_byte_no_sp(cast_coll_type,
            val_str.ptr(), len_byte));
        res_len = static_cast<int32_t>(ObCharset::strlen_char(cast_coll_type,
            val_str.ptr(), trunc_len_byte));
      }
      if (type1.is_numeric_type() && !type1.is_integer_type()) {
        res_len += 1;
      }
    }
  }
  return ret;
}

int ObJsonExprHelper::parse_res_type(ObExprResType& type1,
                                     ObExprResType& res_type,
                                     ObExprResType& result_type,
                                     ObExprTypeCtx& type_ctx)
{
  INIT_SUCC(ret);
  const int32_t VARCHAR2_DEFAULT_LEN = 4000;
  ObExprResType dst_type;
  const ObObj &param = res_type.get_param();

  if (param.get_int() == 0) {
    //     result_type.set_type(type1.get_type());
    //     result_type.set_collation_type(type1.get_collation_type());
    //     result_type.set_accuracy(type1.get_accuracy());
    //     ObObjType obj_type = type1.get_type();

    ObObjType obj_type = ObJsonType;
    result_type.set_type(ObJsonType);
    result_type.set_collation_type(CS_TYPE_UTF8MB4_BIN);
    int16_t length_semantics = (OB_NOT_NULL(type_ctx.get_session())
                ? type_ctx.get_session()->get_actual_nls_length_semantics() : LS_BYTE);
    result_type.set_length((ObAccuracy::DDL_DEFAULT_ACCURACY[ObJsonType]).get_length());

    result_type.set_collation_level(CS_LEVEL_IMPLICIT);
  } else if (OB_FAIL(ObJsonExprHelper::get_cast_type(res_type, dst_type))) {
    LOG_WARN("get cast dest type failed", K(ret));
  } else if (OB_FAIL(ObJsonExprHelper::set_dest_type(type1, result_type, dst_type, type_ctx))) {
    LOG_WARN("set dest type failed", K(ret));
  } else {
    result_type.set_calc_collation_type(result_type.get_collation_type());
  }

  return ret;
}

int ObJsonExprHelper::eval_and_check_res_type(int64_t value, ObObjType& type, int32_t& dst_len)
{
  INIT_SUCC(ret);
  ParseNode node;
  node.value_ = value;
  ObObjType dst_type = static_cast<ObObjType>(node.int16_values_[0]);
  dst_len = node.int32_values_[OB_NODE_CAST_C_LEN_IDX];
  if (dst_type != ObVarcharType
      && dst_type != ObLongTextType
      && dst_type != ObJsonType) {
    ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
    LOG_USER_ERROR(OB_ERR_INVALID_DATA_TYPE_RETURNING);
  } else {
    type = dst_type;
  }
  return ret;
}
// JSON_EXPR_FLAG 0 json value , 1 json query
int ObJsonExprHelper::check_item_func_with_return(ObJsonPathNodeType path_type, ObObjType dst_type, common::ObCollationType dst_coll_type, int8_t JSON_EXPR_FLAG)
{
  INIT_SUCC(ret);
  switch (path_type) {
    case JPN_ABS :{
      break;
    }
    case JPN_BOOLEAN :
    case JPN_BOOL_ONLY :{
      if (dst_type == ObVarcharType) {
      } else {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is double, but return type is ", K(dst_type), K(ret));
      }
      break;
    }
    case JPN_DATE :{
      if (dst_type == ObDateTimeType) {
      } else {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is double, but return type is ", K(dst_type), K(ret));
      }
      break;
    }
    case JPN_DOUBLE :{
      if (dst_type == ObDoubleType || dst_type == ObUDoubleType) {
      } else {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is double, but return type is ", K(dst_type), K(ret));
      }
      break;
    }
    case JPN_FLOOR :
    case JPN_CEILING :
    case JPN_LENGTH :
    case JPN_NUMBER :
    case JPN_NUM_ONLY :
    case JPN_SIZE :{
      if (JSON_EXPR_FLAG == 1 || (JSON_EXPR_FLAG == 0 && dst_type == ObNumberType)) {
      } else {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is lower/upper, but return type is ", K(dst_type), K(ret));
      }
      break;
    }

    case JPN_TIMESTAMP :{
      if (dst_type != ObTimestampNanoType && dst_type != ObTimestampType) {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is type, but return type is ", K(dst_type), K(ret));
      }
      break;
    }
    case JPN_TYPE :{
      if (dst_type == ObJsonType && JSON_EXPR_FLAG != 1) {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is type, but return type is ", K(dst_type), K(ret));
      }
    }
    case JPN_STRING :
    case JPN_STR_ONLY :
    case JPN_LOWER :
    case JPN_UPPER :{
      if (dst_type == ObVarcharType || (dst_type == ObLongTextType && dst_coll_type != CS_TYPE_BINARY)) {
      } else {
        ret = OB_ERR_INVALID_DATA_TYPE_RETURNING;
        LOG_WARN("item func is lower/upper, but return type is ", K(dst_type), K(ret));
      }
      break;
    }
    default :{
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("can't find right path type", K(ret));
    }
  }
  return ret;
}

int ObJsonExprHelper::get_expr_option_value(const ObExprResType param_type2, int64_t &dst_type)
{
  INIT_SUCC(ret);
  if (!param_type2.is_int() && !param_type2.get_param().is_int()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("cast param type is unexpected", K(param_type2));
  } else {
    dst_type = param_type2.get_param().get_int();
  }
  return ret;
}

int ObJsonExprHelper::calc_asciistr_in_expr(const ObString &src,
                                            const ObCollationType src_cs_type,
                                            const ObCollationType dst_cs_type,
                                            char* buf, const int64_t buf_len, int32_t &pos)
{
  int ret = OB_SUCCESS;
  ObStringScanner scanner(src, src_cs_type);
  ObString encoding;
  int32_t wchar = 0;

  while (OB_SUCC(ret)
         && scanner.next_character(encoding, wchar, ret)) {

    if (ob_isascii(wchar) && '\\' != wchar) {
      int32_t written_bytes = 0;

      if (OB_FAIL(ObCharset::wc_mb(dst_cs_type, wchar,
                                   buf + pos, buf_len - pos, written_bytes))) {
        LOG_WARN("fail to convert unicode to multi-byte", K(ret), K(wchar));
      } else {
        pos += written_bytes;
      }
    } else {
      const int64_t temp_buf_len = 4;
      char temp_buf[temp_buf_len];
      int32_t temp_written_bytes = 0;

      if (OB_FAIL(ObCharset::wc_mb(CS_TYPE_UTF16_BIN, wchar,
                                   temp_buf, temp_buf_len, temp_written_bytes))) {
        LOG_WARN("fail to convert unicode to multi-byte", K(ret), K(wchar));
      } else {
        const int utf16_minmb_len = 2;

        if (OB_UNLIKELY(ObCharset::is_cs_nonascii(dst_cs_type))) {
          // not support non-ascii database charset for now
          ret = OB_NOT_SUPPORTED;
          LOG_USER_ERROR(OB_NOT_SUPPORTED, "charset except ascii");
          LOG_WARN("not support charset", K(ret), K(dst_cs_type));
        } else {
          for (int i = 0; OB_SUCC(ret) && i < temp_written_bytes/utf16_minmb_len; ++i) {
            if (OB_UNLIKELY(pos >= buf_len)) {
              ret = OB_SIZE_OVERFLOW;
              LOG_WARN("size overflow", K(ret), K(pos), K(buf_len));
            } else {
              buf[pos++] = '\\';
            }
            if (OB_SUCC(ret)) {
              int64_t hex_writtern_bytes = 0;
              if (OB_FAIL(hex_print(temp_buf + i*utf16_minmb_len, utf16_minmb_len,
                                    buf + pos, buf_len - pos, hex_writtern_bytes))) {
                LOG_WARN("fail to convert to hex", K(ret), K(temp_written_bytes), K(pos), K(buf_len));
              } else {
                pos += hex_writtern_bytes;
              }
            }
          }
        }
      }
    }
  }
  return ret;
}

int ObJsonExprHelper::parse_asc_option(ObExprResType& asc_type,
                                       ObExprResType& type1,
                                       ObExprResType& res_type,
                                       ObExprTypeCtx& type_ctx)
{
  INIT_SUCC(ret);
  ObExprResType temp_type;
  ObObjType doc_type = type1.get_type();
  int64_t asc_option = 0;

  if (asc_type.get_type() != ObIntType) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("<ASCII type> param type is unexpected", K(asc_type.get_type()));
  } else if (OB_FAIL(ObJsonExprHelper::get_expr_option_value(asc_type, asc_option))) {
    LOG_WARN("get ascii type fail", K(ret));
  } else if (asc_option == 1
             && ob_is_string_type(doc_type)
             && ((res_type.is_character_type() && (res_type.get_length_semantics() == LS_CHAR || res_type.get_length_semantics() == LS_BYTE))
                  || res_type.is_lob())) {
    type1.set_calc_length_semantics(res_type.get_length_semantics());
    ObLength length = 0;
    ObExprResType temp_type;
    temp_type.set_meta(type1.get_calc_meta());
    temp_type.set_length_semantics(res_type.get_length_semantics());

    if (doc_type == ObNCharType) {
      length = type1.get_param().get_string_len() * ObCharset::MAX_MB_LEN * 2;
      type1.set_calc_length(length);
      res_type.set_length(length);
    } else if (!temp_type.is_blob() && OB_FAIL(ObExprResultTypeUtil::deduce_max_string_length_oracle(
      type_ctx.get_session()->get_dtc_params(), type1, temp_type, length))) {
      LOG_WARN("fail to deduce max string length.", K(ret), K(temp_type), K(type1));
    } else {
      type1.set_calc_length(length);
      res_type.set_length(length * 10);
      if (res_type.is_lob()) {
        res_type.set_length((ObAccuracy::DDL_DEFAULT_ACCURACY[ObLongTextType]).get_length());
      }
    }
  }

  return ret;
}

int ObJsonExprHelper::character2_ascii_string(common::ObIAllocator *allocator,
                                              const ObExpr &expr,
                                              ObEvalCtx &ctx,
                                              ObString& result,
                                              int32_t reserve_len)
{
  INIT_SUCC(ret);
  char *buf = NULL;
  int64_t buf_len = result.length() * ObCharset::MAX_MB_LEN * 2;
  int32_t length = 0;

  if ((OB_NOT_NULL(allocator) && OB_ISNULL(buf = static_cast<char*>(allocator->alloc(buf_len + reserve_len + 1))))
       || (OB_ISNULL(allocator) && OB_ISNULL(buf = static_cast<char*>(expr.get_str_res_mem(ctx, buf_len + reserve_len + 1))))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_WARN("fail to allocate memory", K(ret), K(buf_len), K(result.length()));
  } else if (OB_FAIL(ObJsonExprHelper::calc_asciistr_in_expr(result,
                                                             expr.datum_meta_.cs_type_,
                                                             expr.datum_meta_.cs_type_,
                                                             buf, buf_len, length))) {
    LOG_WARN("fail to calc unistr", K(ret));
  } else {
    buf[length] = 0;
    result.assign_ptr(buf, length);
  }
  return ret;
}

int ObJsonExprHelper::pre_default_value_check(ObObjType dst_type, ObString time_str, ObObjType val_type) {
  INIT_SUCC(ret);
  size_t len;
  switch (dst_type) {
    case ObTinyTextType:
    case ObTextType:
    case ObMediumTextType:
    case ObLongTextType:
    case ObVarcharType:
    case ObCharType:
    case ObHexStringType:
    case ObRawType:
    case ObNVarchar2Type:
    case ObNCharType: {
      if (lib::is_oracle_mode() && val_type != ObVarcharType && val_type != ObCharType) {
        ret = OB_ERR_DEFAULT_VALUE_NOT_MATCH;
        LOG_WARN("default value not match",K(ret));
      }
      break;
    }
    case ObNumberType: {
      if (val_type == ObNumberType) {
      } else {
        len = time_str.length();
        for(size_t i = 0; i < len; i++) {
          if (time_str[i] == '-' || time_str[i] == '+') {
          } else if (time_str[i] > '9' || time_str[i] < '0') {
            ret = OB_ERR_INVALID_DEFAULT_VALUE_PROVIDED;
            LOG_WARN("number check fail");
          }
        }
      }
      break;
    }
    case ObDateType:
    case ObTimestampNanoType:
    case ObTimestampTZType:
    case ObDateTimeType:
    case ObTimestampLTZType: {
      if (val_type != ObCharType) {
        ret = OB_ERR_INVALID_DEFAULT_VALUE_PROVIDED;
      } else {
        len = time_str.length();
        if(len >= 5 && time_str[4] != '-') {
          ret = OB_ERR_INVALID_DEFAULT_VALUE_PROVIDED;
        } else if(len >= 8 && time_str[7] != '-') {
          ret = OB_ERR_INVALID_DEFAULT_VALUE_PROVIDED;
        }
      }
      break;
    }
    default:
      break;
  }
  return ret;
}

}
}