fix timediff bug

deps/oblib/src/lib/timezone/ob_time_convert.cpp

@@ -31,8 +31,8 @@ using namespace oceanbase::obmysql;
 namespace oceanbase {
 namespace common {
 
-int check_and_get_tz_info(ObTime& ob_time, const ObTimeConvertCtx& cvrt_ctx, const ObTimeZoneInfo*& tz_info,
-    ObTimeZoneInfoPos*& literal_tz_info, ObTZInfoIDPosMap*& tz_id_pos_map);
+int check_and_get_tz_info(ObTime &ob_time, const ObTimeConvertCtx &cvrt_ctx, const ObTimeZoneInfo *&tz_info,
+    ObTimeZoneInfoPos *&literal_tz_info, ObTZInfoIDPosMap *&tz_id_pos_map);
 
 ObTimeConverter::ObTimeConverter()
 {}
@@ -198,7 +198,7 @@ static const ObTimeConstStr MDAY_NAMES[31 + 1] = {{"null", 4},
     {"30th", 4},
     {"31st", 4}};
 
-static const char* DAY_NAME[31 + 1] = {"0th",
+static const char *DAY_NAME[31 + 1] = {"0th",
     "1st",
     "2nd",
     "3rd",
@@ -375,7 +375,7 @@ const ObOracleTimeLimiter ObIntervalLimit::SECOND = {0, 59, OB_ERR_INTERVAL_INVA
 const ObOracleTimeLimiter ObIntervalLimit::FRACTIONAL_SECOND = {
     0, static_cast<int32_t>(power_of_10[9] - 1), OB_ERR_INTERVAL_INVALID};
 
-int ObTime::set_tz_name(const ObString& tz_name)
+int ObTime::set_tz_name(const ObString &tz_name)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(tz_name.empty()) || OB_UNLIKELY(tz_name.length() >= OB_MAX_TZ_NAME_LEN)) {
@@ -394,7 +394,7 @@ int ObTime::set_tz_name(const ObString& tz_name)
   return ret;
 }
 
-int ObTime::set_tzd_abbr(const ObString& tzd_abbr)
+int ObTime::set_tzd_abbr(const ObString &tzd_abbr)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(tzd_abbr.empty()) || OB_UNLIKELY(tzd_abbr.length() >= OB_MAX_TZ_ABBR_LEN)) {
@@ -432,7 +432,7 @@ DEF_TO_STRING(ObTime)
 ////////////////////////////////
 // int / double / string -> datetime / date / time / year.
 int ObTimeConverter::int_to_datetime(
-    int64_t int_part, int64_t dec_part, const ObTimeConvertCtx& cvrt_ctx, int64_t& value)
+    int64_t int_part, int64_t dec_part, const ObTimeConvertCtx &cvrt_ctx, int64_t &value)
 {
   int ret = OB_SUCCESS;
   dec_part = (dec_part + 500) / 1000;
@@ -454,7 +454,7 @@ int ObTimeConverter::int_to_datetime(
   return ret;
 }
 
-int ObTimeConverter::int_to_date(int64_t int64, int32_t& value)
+int ObTimeConverter::int_to_date(int64_t int64, int32_t &value)
 {
   int ret = OB_SUCCESS;
   if (0 == int64) {
@@ -470,7 +470,7 @@ int ObTimeConverter::int_to_date(int64_t int64, int32_t& value)
   return ret;
 }
 
-int ObTimeConverter::int_to_time(int64_t int64, int64_t& value)
+int ObTimeConverter::int_to_time(int64_t int64, int64_t &value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_TIME);
@@ -486,7 +486,7 @@ int ObTimeConverter::int_to_time(int64_t int64, int64_t& value)
   return ret;
 }
 
-int ObTimeConverter::int_to_year(int64_t int_val, uint8_t& value)
+int ObTimeConverter::int_to_year(int64_t int_val, uint8_t &value)
 {
   int ret = OB_SUCCESS;
   if (0 == int_val) {
@@ -506,7 +506,7 @@ int ObTimeConverter::int_to_year(int64_t int_val, uint8_t& value)
 }
 
 int ObTimeConverter::str_to_datetime(
-    const ObString& str, const ObTimeConvertCtx& cvrt_ctx, int64_t& value, int16_t* scale)
+    const ObString &str, const ObTimeConvertCtx &cvrt_ctx, int64_t &value, int16_t *scale)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_DATETIME);
@@ -539,7 +539,7 @@ int ObTimeConverter::str_to_datetime(
  * @param out:  value     oracle date result value
  */
 int ObTimeConverter::literal_date_validate_oracle(
-    const ObString& str, const ObTimeConvertCtx& cvrt_ctx, ObDateTime& value)
+    const ObString &str, const ObTimeConvertCtx &cvrt_ctx, ObDateTime &value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -563,7 +563,7 @@ int ObTimeConverter::literal_date_validate_oracle(
  * @param out:    value     ObOTimestampData result value
  */
 int ObTimeConverter::literal_timestamp_validate_oracle(
-    const ObString& str, const ObTimeConvertCtx& cvrt_ctx, ObObjType& obj_type, ObOTimestampData& value)
+    const ObString &str, const ObTimeConvertCtx &cvrt_ctx, ObObjType &obj_type, ObOTimestampData &value)
 {
   int ret = OB_SUCCESS;
   value.reset();
@@ -586,13 +586,13 @@ int ObTimeConverter::literal_timestamp_validate_oracle(
 }
 
 int ObTimeConverter::literal_interval_ym_validate_oracle(
-    const ObString& str, ObIntervalYMValue& value, ObScale& scale, ObDateUnitType part_begin, ObDateUnitType part_end)
+    const ObString &str, ObIntervalYMValue &value, ObScale &scale, ObDateUnitType part_begin, ObDateUnitType part_end)
 {
   return str_to_interval_ym(str, value, scale, part_begin, part_end);
 }
 
 int ObTimeConverter::literal_interval_ds_validate_oracle(
-    const ObString& str, ObIntervalDSValue& value, ObScale& scale, ObDateUnitType part_begin, ObDateUnitType part_end)
+    const ObString &str, ObIntervalDSValue &value, ObScale &scale, ObDateUnitType part_begin, ObDateUnitType part_end)
 {
   return str_to_interval_ds(str, value, scale, part_begin, part_end);
 }
@@ -604,7 +604,7 @@ int ObTimeConverter::literal_interval_ds_validate_oracle(
  * @param out:    value     oracle DATE result
  * @return
  */
-int ObTimeConverter::str_to_date_oracle(const ObString& str, const ObTimeConvertCtx& cvrt_ctx, ObDateTime& value)
+int ObTimeConverter::str_to_date_oracle(const ObString &str, const ObTimeConvertCtx &cvrt_ctx, ObDateTime &value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -629,8 +629,8 @@ int ObTimeConverter::str_to_date_oracle(const ObString& str, const ObTimeConvert
  * @param out:    scale         scale of fractional seconds
  * @return
  */
-int ObTimeConverter::str_to_otimestamp(const ObString& str, const ObTimeConvertCtx& cvrt_ctx,
-    const ObObjType target_type, ObOTimestampData& value, ObScale& scale)
+int ObTimeConverter::str_to_otimestamp(const ObString &str, const ObTimeConvertCtx &cvrt_ctx,
+    const ObObjType target_type, ObOTimestampData &value, ObScale &scale)
 {
   int ret = OB_SUCCESS;
   value.reset();
@@ -675,13 +675,13 @@ int ObTimeConverter::str_to_otimestamp(const ObString& str, const ObTimeConvertC
  * @param in, out:    ob_time
  * @return
  */
-int ObTimeConverter::calc_tz_offset_by_tz_name(const ObTimeConvertCtx& cvrt_ctx, ObTime& ob_time)
+int ObTimeConverter::calc_tz_offset_by_tz_name(const ObTimeConvertCtx &cvrt_ctx, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   int64_t usec = ob_time.parts_[DT_DATE] * USECS_PER_DAY + ob_time_to_time(ob_time);
-  const ObTimeZoneInfo* tz_info = NULL;
-  ObTimeZoneInfoPos* literal_tz_info = NULL;
-  ObTZInfoIDPosMap* tz_id_pos_map = NULL;
+  const ObTimeZoneInfo *tz_info = NULL;
+  ObTimeZoneInfoPos *literal_tz_info = NULL;
+  ObTZInfoIDPosMap *tz_id_pos_map = NULL;
   int32_t tz_id = OB_INVALID_INDEX;
   int32_t tran_type_id = OB_INVALID_INDEX;
   int32_t offset_min = 0;
@@ -749,7 +749,7 @@ int ObTimeConverter::get_oracle_err_when_datetime_parts_conflict(int64_t part_id
   return ret;
 }
 
-int ObTimeConverter::str_to_tz_offset(const ObTimeConvertCtx& cvrt_ctx, ObTime& ob_time)
+int ObTimeConverter::str_to_tz_offset(const ObTimeConvertCtx &cvrt_ctx, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (!ob_time.is_tz_name_valid_) {
@@ -760,7 +760,7 @@ int ObTimeConverter::str_to_tz_offset(const ObTimeConvertCtx& cvrt_ctx, ObTime&
   return ret;
 }
 
-int ObTimeConverter::ob_time_to_utc(const ObObjType obj_type, const ObTimeConvertCtx& cvrt_ctx, ObTime& ob_time)
+int ObTimeConverter::ob_time_to_utc(const ObObjType obj_type, const ObTimeConvertCtx &cvrt_ctx, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (ObTimestampNanoType == obj_type) {
@@ -810,7 +810,7 @@ int ObTimeConverter::ob_time_to_utc(const ObObjType obj_type, const ObTimeConver
 }
 
 int ObTimeConverter::str_to_datetime_format(
-    const ObString& str, const ObString& fmt, const ObTimeConvertCtx& cvrt_ctx, int64_t& value, int16_t* scale)
+    const ObString &str, const ObString &fmt, const ObTimeConvertCtx &cvrt_ctx, int64_t &value, int16_t *scale)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_DATETIME);
@@ -822,7 +822,7 @@ int ObTimeConverter::str_to_datetime_format(
   return ret;
 }
 
-int ObTimeConverter::str_to_date(const ObString& str, int32_t& value)
+int ObTimeConverter::str_to_date(const ObString &str, int32_t &value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_DATE);
@@ -834,7 +834,7 @@ int ObTimeConverter::str_to_date(const ObString& str, int32_t& value)
   return ret;
 }
 
-int ObTimeConverter::str_to_time(const ObString& str, int64_t& value, int16_t* scale)
+int ObTimeConverter::str_to_time(const ObString &str, int64_t &value, int16_t *scale)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_TIME);
@@ -850,15 +850,15 @@ int ObTimeConverter::str_to_time(const ObString& str, int64_t& value, int16_t* s
   return ret;
 }
 
-int ObTimeConverter::str_to_year(const ObString& str, uint8_t& value)
+int ObTimeConverter::str_to_year(const ObString &str, uint8_t &value)
 {
   int ret = OB_SUCCESS;
   if (NULL == str.ptr() || 0 == str.length()) {
     ret = OB_ALLOCATE_MEMORY_FAILED;
     LOG_ERROR("failed to alloc memory", K(ret));
   } else {
-    const char* pos = str.ptr();
-    const char* end = pos + str.length();
+    const char *pos = str.ptr();
+    const char *end = pos + str.length();
     ObTimeDigits digits;
     for (; !isdigit(*pos) && pos < end; ++pos) {}
     if (OB_FAIL(get_datetime_digits(pos, end, INT32_MAX, digits))) {
@@ -875,7 +875,7 @@ int ObTimeConverter::str_to_year(const ObString& str, uint8_t& value)
   return ret;
 }
 
-int ObTimeConverter::str_to_interval(const ObString& str, ObDateUnitType unit_type, int64_t& value)
+int ObTimeConverter::str_to_interval(const ObString &str, ObDateUnitType unit_type, int64_t &value)
 {
   int ret = OB_SUCCESS;
   ObInterval ob_interval;
@@ -890,7 +890,7 @@ int ObTimeConverter::str_to_interval(const ObString& str, ObDateUnitType unit_ty
 ////////////////////////////////
 // int / double / uint / string <- datetime / date / time / year.
 
-int ObTimeConverter::datetime_to_int(int64_t value, const ObTimeZoneInfo* tz_info, int64_t& int64)
+int ObTimeConverter::datetime_to_int(int64_t value, const ObTimeZoneInfo *tz_info, int64_t &int64)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -902,7 +902,7 @@ int ObTimeConverter::datetime_to_int(int64_t value, const ObTimeZoneInfo* tz_inf
   return ret;
 }
 
-int ObTimeConverter::datetime_to_double(int64_t value, const ObTimeZoneInfo* tz_info, double& dbl)
+int ObTimeConverter::datetime_to_double(int64_t value, const ObTimeZoneInfo *tz_info, double &dbl)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -916,8 +916,8 @@ int ObTimeConverter::datetime_to_double(int64_t value, const ObTimeZoneInfo* tz_
 }
 
 // ObDatetimeType: tz_info = NULL. ObTimestampType: tz_info != NULL.
-int ObTimeConverter::datetime_to_str(int64_t value, const ObTimeZoneInfo* tz_info, const ObString& nls_format,
-    int16_t scale, char* buf, int64_t buf_len, int64_t& pos, bool with_delim)
+int ObTimeConverter::datetime_to_str(int64_t value, const ObTimeZoneInfo *tz_info, const ObString &nls_format,
+    int16_t scale, char *buf, int64_t buf_len, int64_t &pos, bool with_delim)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -938,14 +938,14 @@ int ObTimeConverter::datetime_to_str(int64_t value, const ObTimeZoneInfo* tz_inf
   return ret;
 }
 
-int ObTimeConverter::otimestamp_to_str(const ObOTimestampData& ot_data, const ObDataTypeCastParams& dtc_params,
-    const int16_t scale, const ObObjType type, char* buf, int64_t buf_len, int64_t& pos)
+int ObTimeConverter::otimestamp_to_str(const ObOTimestampData &ot_data, const ObDataTypeCastParams &dtc_params,
+    const int16_t scale, const ObObjType type, char *buf, int64_t buf_len, int64_t &pos)
 {
   int ret = OB_SUCCESS;
   if (ot_data.is_null_value()) {
     LOG_DEBUG("succ to null otimestamp_to_str", K(ot_data), K(type), K(scale), K(lbt()));
   } else {
-    const ObOTimestampData& tmp_ot_data = round_otimestamp(scale, ot_data);
+    const ObOTimestampData &tmp_ot_data = round_otimestamp(scale, ot_data);
     const bool store_utc_time = false;
     ObTime ob_time(DT_TYPE_ORACLE_TIMESTAMP);
     const int64_t old_pos = pos;
@@ -965,7 +965,7 @@ int ObTimeConverter::otimestamp_to_str(const ObOTimestampData& ot_data, const Ob
   return ret;
 }
 
-int ObTimeConverter::date_to_int(int32_t value, int64_t& int64)
+int ObTimeConverter::date_to_int(int32_t value, int64_t &int64)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -977,7 +977,7 @@ int ObTimeConverter::date_to_int(int32_t value, int64_t& int64)
   return ret;
 }
 
-int ObTimeConverter::date_to_str(int32_t value, char* buf, int64_t buf_len, int64_t& pos)
+int ObTimeConverter::date_to_str(int32_t value, char *buf, int64_t buf_len, int64_t &pos)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -989,7 +989,7 @@ int ObTimeConverter::date_to_str(int32_t value, char* buf, int64_t buf_len, int6
   return ret;
 }
 
-int ObTimeConverter::time_to_int(int64_t value, int64_t& int64)
+int ObTimeConverter::time_to_int(int64_t value, int64_t &int64)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1004,7 +1004,7 @@ int ObTimeConverter::time_to_int(int64_t value, int64_t& int64)
   return ret;
 }
 
-int ObTimeConverter::time_to_double(int64_t value, double& dbl)
+int ObTimeConverter::time_to_double(int64_t value, double &dbl)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1019,8 +1019,8 @@ int ObTimeConverter::time_to_double(int64_t value, double& dbl)
   }
   return ret;
 }
-int ObTimeConverter::time_to_datetime(int64_t t_value, int64_t cur_dt_value, const ObTimeZoneInfo* tz_info,
-    int64_t& dt_value, const ObObjType expect_type)
+int ObTimeConverter::time_to_datetime(int64_t t_value, int64_t cur_dt_value, const ObTimeZoneInfo *tz_info,
+    int64_t &dt_value, const ObObjType expect_type)
 {
   int ret = OB_SUCCESS;
   if (ObTimestampType == expect_type) {
@@ -1052,7 +1052,7 @@ int ObTimeConverter::time_to_datetime(int64_t t_value, int64_t cur_dt_value, con
 }
 
 int ObTimeConverter::time_to_str(
-    int64_t value, int16_t scale, char* buf, int64_t buf_len, int64_t& pos, bool with_delim)
+    int64_t value, int16_t scale, char *buf, int64_t buf_len, int64_t &pos, bool with_delim)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1065,7 +1065,7 @@ int ObTimeConverter::time_to_str(
   return ret;
 }
 
-int ObTimeConverter::year_to_int(uint8_t value, int64_t& int64)
+int ObTimeConverter::year_to_int(uint8_t value, int64_t &int64)
 {
   int64 = (ZERO_YEAR == value) ? 0 : value + YEAR_BASE_YEAR;
   return OB_SUCCESS;
@@ -1074,7 +1074,7 @@ int ObTimeConverter::year_to_int(uint8_t value, int64_t& int64)
 #define YEAR_STR_FMT "%.4d"
 #define YEAR_STR_LEN 4
 
-int ObTimeConverter::year_to_str(uint8_t value, char* buf, int64_t buf_len, int64_t& pos)
+int ObTimeConverter::year_to_str(uint8_t value, char *buf, int64_t buf_len, int64_t &pos)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(buf) || OB_UNLIKELY(buf_len <= 0 || pos < 0)) {
@@ -1089,7 +1089,7 @@ int ObTimeConverter::year_to_str(uint8_t value, char* buf, int64_t buf_len, int6
 ////////////////////////////////
 // inner cast between datetime, timestamp, date, time, year.
 
-int ObTimeConverter::datetime_to_timestamp(int64_t dt_value, const ObTimeZoneInfo* tz_info, int64_t& ts_value)
+int ObTimeConverter::datetime_to_timestamp(int64_t dt_value, const ObTimeZoneInfo *tz_info, int64_t &ts_value)
 {
   int ret = OB_SUCCESS;
   ts_value = dt_value;
@@ -1100,7 +1100,7 @@ int ObTimeConverter::datetime_to_timestamp(int64_t dt_value, const ObTimeZoneInf
   return ret;
 }
 
-int ObTimeConverter::timestamp_to_datetime(int64_t ts_value, const ObTimeZoneInfo* tz_info, int64_t& dt_value)
+int ObTimeConverter::timestamp_to_datetime(int64_t ts_value, const ObTimeZoneInfo *tz_info, int64_t &dt_value)
 {
   int ret = OB_SUCCESS;
   dt_value = ts_value;
@@ -1114,7 +1114,7 @@ int ObTimeConverter::timestamp_to_datetime(int64_t ts_value, const ObTimeZoneInf
 //                timestamp ltz(utc)
 //                timestamp (local)
 int ObTimeConverter::odate_to_otimestamp(
-    int64_t in_value_us, const ObTimeZoneInfo* tz_info, const ObObjType out_type, ObOTimestampData& out_value)
+    int64_t in_value_us, const ObTimeZoneInfo *tz_info, const ObObjType out_type, ObOTimestampData &out_value)
 {
   int ret = OB_SUCCESS;
   if (ZERO_DATETIME == in_value_us) {
@@ -1161,7 +1161,7 @@ int ObTimeConverter::odate_to_otimestamp(
 // timestamp ltz(utc)        --> date(local)
 // timestamp (local)         --> date(local)
 int ObTimeConverter::otimestamp_to_odate(
-    const ObObjType in_type, const ObOTimestampData& in_value, const ObTimeZoneInfo* tz_info, int64_t& out_usec)
+    const ObObjType in_type, const ObOTimestampData &in_value, const ObTimeZoneInfo *tz_info, int64_t &out_usec)
 {
   int ret = OB_SUCCESS;
   if (in_value.is_null_value()) {
@@ -1191,8 +1191,8 @@ int ObTimeConverter::otimestamp_to_odate(
   return ret;
 }
 
-int ObTimeConverter::otimestamp_to_otimestamp(const ObObjType in_type, const ObOTimestampData& in_value,
-    const ObTimeZoneInfo* tz_info, const ObObjType out_type, ObOTimestampData& out_value)
+int ObTimeConverter::otimestamp_to_otimestamp(const ObObjType in_type, const ObOTimestampData &in_value,
+    const ObTimeZoneInfo *tz_info, const ObObjType out_type, ObOTimestampData &out_value)
 {
   int ret = OB_SUCCESS;
   out_value.reset();
@@ -1232,19 +1232,19 @@ int ObTimeConverter::otimestamp_to_otimestamp(const ObObjType in_type, const ObO
 }
 
 int ObTimeConverter::extract_offset_from_otimestamp(
-    const ObOTimestampData& in_value, const ObTimeZoneInfo* tz_info, int32_t& offset_min, ObTime& ob_time)
+    const ObOTimestampData &in_value, const ObTimeZoneInfo *tz_info, int32_t &offset_min, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (in_value.time_ctx_.store_tz_id_) {
-    ObTZInfoMap* tz_info_map = NULL;
-    ObTimeZoneInfoPos* literal_tz_info = NULL;
+    ObTZInfoMap *tz_info_map = NULL;
+    ObTimeZoneInfoPos *literal_tz_info = NULL;
     ObString tz_name_str;
     ObString tz_abbr_str;
     int32_t offset_sec = 0;
     if (OB_ISNULL(tz_info)) {
       ret = OB_ERR_NULL_VALUE;
       LOG_WARN("tz_info is null", K(ret));
-    } else if (OB_ISNULL(tz_info_map = const_cast<ObTZInfoMap*>(tz_info->get_tz_info_map()))) {
+    } else if (OB_ISNULL(tz_info_map = const_cast<ObTZInfoMap *>(tz_info->get_tz_info_map()))) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("tz_info_map is NULL", K(ret));
     } else if (OB_FAIL(tz_info_map->get_tz_info_by_id(in_value.time_ctx_.tz_id_, literal_tz_info))) {
@@ -1279,7 +1279,7 @@ int ObTimeConverter::extract_offset_from_otimestamp(
   return ret;
 }
 
-int ObTimeConverter::datetime_to_date(int64_t dt_value, const ObTimeZoneInfo* tz_info, int32_t& d_value)
+int ObTimeConverter::datetime_to_date(int64_t dt_value, const ObTimeZoneInfo *tz_info, int32_t &d_value)
 {
   int ret = OB_SUCCESS;
   if (ZERO_DATETIME == dt_value) {
@@ -1295,7 +1295,7 @@ int ObTimeConverter::datetime_to_date(int64_t dt_value, const ObTimeZoneInfo* tz
   return ret;
 }
 
-int ObTimeConverter::datetime_to_time(int64_t dt_value, const ObTimeZoneInfo* tz_info, int64_t& t_value)
+int ObTimeConverter::datetime_to_time(int64_t dt_value, const ObTimeZoneInfo *tz_info, int64_t &t_value)
 {
   int ret = OB_SUCCESS;
   if (OB_FAIL(add_timezone_offset(tz_info, dt_value))) {
@@ -1309,7 +1309,7 @@ int ObTimeConverter::datetime_to_time(int64_t dt_value, const ObTimeZoneInfo* tz
   return ret;
 }
 
-int ObTimeConverter::datetime_to_year(int64_t dt_value, const ObTimeZoneInfo* tz_info, uint8_t& y_value)
+int ObTimeConverter::datetime_to_year(int64_t dt_value, const ObTimeZoneInfo *tz_info, uint8_t &y_value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1325,7 +1325,7 @@ int ObTimeConverter::datetime_to_year(int64_t dt_value, const ObTimeZoneInfo* tz
   return ret;
 }
 
-int ObTimeConverter::date_to_datetime(int32_t d_value, const ObTimeConvertCtx& cvrt_ctx, int64_t& dt_value)
+int ObTimeConverter::date_to_datetime(int32_t d_value, const ObTimeConvertCtx &cvrt_ctx, int64_t &dt_value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1339,7 +1339,7 @@ int ObTimeConverter::date_to_datetime(int32_t d_value, const ObTimeConvertCtx& c
   return ret;
 }
 
-int ObTimeConverter::date_to_year(int32_t d_value, uint8_t& y_value)
+int ObTimeConverter::date_to_year(int32_t d_value, uint8_t &y_value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1355,7 +1355,7 @@ int ObTimeConverter::date_to_year(int32_t d_value, uint8_t& y_value)
   return ret;
 }
 
-int ObTimeConverter::check_leading_precision(const ObTimeDigits& digits)
+int ObTimeConverter::check_leading_precision(const ObTimeDigits &digits)
 {
   int ret = OB_SUCCESS;
   const int64_t oracle_max_leading_precision = 9;
@@ -1388,18 +1388,18 @@ int ObTimeConverter::check_leading_precision(const ObTimeDigits& digits)
  * ret_more records this error code, and if search time_zone_map failed, we choose whether
  * set ret = ret_more according to compatible mode.
  */
-int ObTimeConverter::str_to_offset(const ObString& str, int32_t& value, int& ret_more, const bool is_oracle_mode,
+int ObTimeConverter::str_to_offset(const ObString &str, int32_t &value, int &ret_more, const bool is_oracle_mode,
     const bool need_check_valid /* false */)
 {
   int ret = OB_SUCCESS;
   ret_more = OB_SUCCESS;
-  const ObString tmp_str = (is_oracle_mode ? const_cast<ObString&>(str).trim() : str);
+  const ObString tmp_str = (is_oracle_mode ? const_cast<ObString &>(str).trim() : str);
   if (OB_ISNULL(tmp_str.ptr()) || OB_UNLIKELY(tmp_str.length() <= 0)) {
     ret = OB_ERR_UNKNOWN_TIME_ZONE;
     LOG_WARN("invalid time zone offset", K(ret), K(str), K(tmp_str));
   } else {
-    const char* pos = tmp_str.ptr();
-    const char* end = pos + tmp_str.length();
+    const char *pos = tmp_str.ptr();
+    const char *end = pos + tmp_str.length();
     char sign = *pos;
     if (is_oracle_mode) {
       // default is +
@@ -1475,7 +1475,7 @@ int ObTimeConverter::str_to_offset(const ObString& str, int32_t& value, int& ret
 ////////////////////////////////
 // year / month / day / quarter / week / hour / minite / second / microsecond.
 
-int ObTimeConverter::int_to_week(int64_t int64, int64_t mode, int32_t& value)
+int ObTimeConverter::int_to_week(int64_t int64, int64_t mode, int32_t &value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time;
@@ -1490,7 +1490,7 @@ int ObTimeConverter::int_to_week(int64_t int64, int64_t mode, int32_t& value)
 ////////////////////////////////
 // other functions.
 
-void ObTimeConverter::round_datetime(int16_t scale, int64_t& value)
+void ObTimeConverter::round_datetime(int16_t scale, int64_t &value)
 {
   if (0 <= scale && scale < 6) {
     int32_t power_of_precision = static_cast<int32_t>(power_of_10[6 - scale]);
@@ -1504,7 +1504,7 @@ void ObTimeConverter::round_datetime(int16_t scale, int64_t& value)
   }  // others, just return the original value.
 }
 
-ObOTimestampData ObTimeConverter::round_otimestamp(const int16_t scale, const ObOTimestampData& in_ot_data)
+ObOTimestampData ObTimeConverter::round_otimestamp(const int16_t scale, const ObOTimestampData &in_ot_data)
 {
   ObOTimestampData ret_ot_data = in_ot_data;
   const int16_t MIN_SCALE = 0;
@@ -1512,7 +1512,7 @@ ObOTimestampData ObTimeConverter::round_otimestamp(const int16_t scale, const Ob
   const int16_t MAX_NS_SCALE = 9;
   if (MIN_SCALE <= scale && scale <= MAX_NS_SCALE) {
     if (scale < MAX_US_SCALE) {
-      round_datetime(scale, *(int64_t*)&ret_ot_data.time_us_);
+      round_datetime(scale, *(int64_t *)&ret_ot_data.time_us_);
       ret_ot_data.time_ctx_.tail_nsec_ = 0;
     } else if (MAX_US_SCALE == scale) {
       if (ret_ot_data.time_ctx_.tail_nsec_ >= power_of_10[MAX_NS_SCALE - MAX_US_SCALE] / 2) {
@@ -1538,7 +1538,7 @@ ObOTimestampData ObTimeConverter::round_otimestamp(const int16_t scale, const Ob
   return ret_ot_data;
 }
 
-int ObTimeConverter::round_interval_ds(const ObScale scale, ObIntervalDSValue& value)
+int ObTimeConverter::round_interval_ds(const ObScale scale, ObIntervalDSValue &value)
 {
   int ret = OB_SUCCESS;
   if (MIN_SCALE_FOR_TEMPORAL <= scale && scale <= MAX_SCALE_FOR_ORACLE_TEMPORAL) {
@@ -1547,7 +1547,7 @@ int ObTimeConverter::round_interval_ds(const ObScale scale, ObIntervalDSValue& v
   return ret;
 }
 
-void ObTimeConverter::trunc_datetime(int16_t scale, int64_t& value)
+void ObTimeConverter::trunc_datetime(int16_t scale, int64_t &value)
 {
   if (0 <= scale && scale <= 6) {
     int32_t usec = static_cast<int32_t>(value % power_of_10[6 - scale]);
@@ -1559,7 +1559,7 @@ void ObTimeConverter::trunc_datetime(int16_t scale, int64_t& value)
 // date add / sub / diff.
 
 int ObTimeConverter::date_adjust(
-    const int64_t base_value, const ObString& interval_str, ObDateUnitType unit_type, int64_t& value, bool is_add)
+    const int64_t base_value, const ObString &interval_str, ObDateUnitType unit_type, int64_t &value, bool is_add)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(unit_type < 0 || unit_type >= DATE_UNIT_MAX)) {
@@ -1581,7 +1581,7 @@ int ObTimeConverter::date_adjust(
 }
 
 int ObTimeConverter::date_adjust(
-    const ObString& base_str, const ObString& interval_str, ObDateUnitType unit_type, int64_t& value, bool is_add)
+    const ObString &base_str, const ObString &interval_str, ObDateUnitType unit_type, int64_t &value, bool is_add)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(unit_type < 0 || unit_type >= DATE_UNIT_MAX)) {
@@ -1607,7 +1607,7 @@ int ObTimeConverter::date_adjust(
 }
 
 int ObTimeConverter::merge_date_interval(
-    int64_t base_value, const ObString& interval_str, ObDateUnitType unit_type, int64_t& value, bool is_add)
+    int64_t base_value, const ObString &interval_str, ObDateUnitType unit_type, int64_t &value, bool is_add)
 {
   int ret = OB_SUCCESS;
   int64_t interval_value = 0;
@@ -1624,7 +1624,7 @@ int ObTimeConverter::merge_date_interval(
 }
 
 int ObTimeConverter::merge_date_interval(
-    /*const*/ ObTime& base_time, const ObString& interval_str, ObDateUnitType unit_type, int64_t& value, bool is_add)
+    /*const*/ ObTime &base_time, const ObString &interval_str, ObDateUnitType unit_type, int64_t &value, bool is_add)
 {
   int ret = OB_SUCCESS;
   ObInterval interval_time;
@@ -1687,10 +1687,10 @@ int ObTimeConverter::merge_date_interval(
 ////////////////////////////////
 // int / uint / string -> ObTime / ObInterval <- datetime / date / time.
 
-int ObTimeConverter::int_to_ob_time_with_date(int64_t int64, ObTime& ob_time, bool is_dayofmonth)
+int ObTimeConverter::int_to_ob_time_with_date(int64_t int64, ObTime &ob_time, bool is_dayofmonth)
 {
   int ret = OB_SUCCESS;
-  int32_t* parts = ob_time.parts_;
+  int32_t *parts = ob_time.parts_;
   if (is_dayofmonth && 0 == int64) {
     parts[DT_SEC] = 0;
     parts[DT_MIN] = 0;
@@ -1736,10 +1736,10 @@ int ObTimeConverter::int_to_ob_time_with_date(int64_t int64, ObTime& ob_time, bo
   return ret;
 }
 
-int ObTimeConverter::int_to_ob_time_without_date(int64_t int64, ObTime& ob_time)
+int ObTimeConverter::int_to_ob_time_without_date(int64_t int64, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
-  int32_t* parts = ob_time.parts_;
+  int32_t *parts = ob_time.parts_;
   ObDTMode mode = DT_TYPE_TIME;
   if (int64 < 0) {
     ob_time.mode_ |= DT_MODE_NEG;
@@ -1799,7 +1799,7 @@ static const int32_t TIMESTAMPTZ_PART_LENS_MAX[] = {
 static const int32_t TIMESTAMPTZ_PART_LENS_YEAR4[] = {4, 2, 2, 2, 2, 2, 10};
 static const int32_t TIMESTAMPTZ_PART_LENS_YEAR2[] = {2, 2, 2, 2, 2, 2, 10};
 
-int ObTimeConverter::get_time_zone(const ObTimeDelims* delims, ObTime& ob_time, const char* end_ptr)
+int ObTimeConverter::get_time_zone(const ObTimeDelims *delims, ObTime &ob_time, const char *end_ptr)
 {
   int ret = OB_SUCCESS;
   int64_t i = 0;
@@ -1807,8 +1807,8 @@ int ObTimeConverter::get_time_zone(const ObTimeDelims* delims, ObTime& ob_time,
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("delimis is NULL", K(ret));
   } else {
-    const char* pos = NULL;
-    const char* end = NULL;
+    const char *pos = NULL;
+    const char *end = NULL;
     if (NULL != delims[DT_SEC].ptr_ && isspace(*delims[DT_SEC].ptr_)) {
       pos = delims[DT_SEC].ptr_;
       end = pos + delims[DT_SEC].len_;
@@ -1842,25 +1842,25 @@ int ObTimeConverter::get_time_zone(const ObTimeDelims* delims, ObTime& ob_time,
   return ret;
 }
 
-int ObTimeConverter::str_to_digit_with_date(const ObString& str, ObTimeDigits* digits, ObTime& ob_time)
+int ObTimeConverter::str_to_digit_with_date(const ObString &str, ObTimeDigits *digits, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr()) || OB_UNLIKELY(str.length() <= 0) || OB_ISNULL(digits)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("invalid argument", K(ret));
   } else {
-    const char* pos = str.ptr();
-    const char* end = pos + str.length();
-    const int32_t* expect_lens = NULL;
+    const char *pos = str.ptr();
+    const char *end = pos + str.length();
+    const int32_t *expect_lens = NULL;
     ObTimeDelims delims[DATETIME_PART_CNT];
     // find first digit and delimiter.
     for (; isspace(*pos) && pos < end; ++pos) {}
     if (!isdigit(*pos)) {
       ret = OB_INVALID_DATE_FORMAT;
     } else {
-      const char* first_digit = pos;
+      const char *first_digit = pos;
       for (; isdigit(*pos) && pos < end; ++pos) {}
-      const char* first_delim = pos;
+      const char *first_delim = pos;
       // year is separated by delimiter, or 4 digits, or 2?
       /*if (HAS_TYPE_ORACLE(ob_time.mode_)) {
         if ('.' != *first_delim && first_delim < end) {
@@ -1901,7 +1901,7 @@ int ObTimeConverter::str_to_digit_with_date(const ObString& str, ObTimeDigits* d
       }
 
       if (OB_SUCC(ret)) {
-        const char* end_ptr = HAS_TYPE_ORACLE(ob_time.mode_) ? end : NULL;
+        const char *end_ptr = HAS_TYPE_ORACLE(ob_time.mode_) ? end : NULL;
         /*if (lib::is_oracle_mode() && !HAS_TYPE_ORACLE(ob_time.mode_) && pos < end) {
           //for date type
           ret = OB_INVALID_DATE_FORMAT_END;
@@ -1947,7 +1947,7 @@ int ObTimeConverter::str_to_digit_with_date(const ObString& str, ObTimeDigits* d
   return ret;
 }
 
-int ObTimeConverter::str_to_ob_time_with_date(const ObString& str, ObTime& ob_time, int16_t* scale, bool is_dayofmonth)
+int ObTimeConverter::str_to_ob_time_with_date(const ObString &str, ObTime &ob_time, int16_t *scale, bool is_dayofmonth)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr()) || OB_UNLIKELY(str.length() <= 0)) {
@@ -1975,7 +1975,7 @@ int ObTimeConverter::str_to_ob_time_with_date(const ObString& str, ObTime& ob_ti
   return ret;
 }
 
-int ObTimeConverter::str_is_date_format(const ObString& str, bool& date_flag)
+int ObTimeConverter::str_is_date_format(const ObString &str, bool &date_flag)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr()) || OB_UNLIKELY(str.length() <= 0)) {
@@ -1998,7 +1998,7 @@ int ObTimeConverter::str_is_date_format(const ObString& str, bool& date_flag)
   return ret;
 }
 
-int ObTimeConverter::str_to_ob_time_without_date(const ObString& str, ObTime& ob_time, int16_t* scale)
+int ObTimeConverter::str_to_ob_time_without_date(const ObString &str, ObTime &ob_time, int16_t *scale)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr()) || OB_UNLIKELY(str.length() <= 0)) {
@@ -2008,11 +2008,11 @@ int ObTimeConverter::str_to_ob_time_without_date(const ObString& str, ObTime& ob
     if (NULL != scale) {
       *scale = 0;
     }
-    const char* pos = str.ptr();
-    const char* end = pos + str.length();
+    const char *pos = str.ptr();
+    const char *end = pos + str.length();
     // find first digit.
     for (; isspace(*pos) && pos < end; ++pos) {}
-    const char* first_digit = pos;
+    const char *first_digit = pos;
     if (!('-' == *pos || isdigit(*pos))) {
       for (int i = 0; OB_SUCC(ret) && i < TOTAL_PART_CNT; ++i) {
         ob_time.parts_[i] = 0;
@@ -2124,18 +2124,17 @@ int ObTimeConverter::str_to_ob_time_without_date(const ObString& str, ObTime& ob
   return ret;
 }
 
-#define GET_YEAR_WEEK_WDAY(len, var, set_state, elem, max, min) \
-  if (OB_SUCC(get_datetime_digits(str_pos, str_end, len, digits))) {  \
-    if (digits.value_ < min || digits.value_ > max) { \
-      ret = OB_INVALID_DATE_VALUE;  \
-    } else {  \
+#define GET_YEAR_WEEK_WDAY(len, var, set_state, elem, max, min)             \
+  if (OB_SUCC(get_datetime_digits(str_pos, str_end, len, digits))) {        \
+    if (digits.value_ < min || digits.value_ > max) {                       \
+      ret = OB_INVALID_DATE_VALUE;                                          \
+    } else {                                                                \
       var.elem##_set_state_ = ObYearWeekWdayElems::ElemSetState::set_state; \
-      var.elem##_value_ = digits.value_;     \
-    }     \
+      var.elem##_value_ = digits.value_;                                    \
+    }                                                                       \
   }
 
-
-int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString& fmt, ObTime& ob_time, int16_t* scale)
+int ObTimeConverter::str_to_ob_time_format(const ObString &str, const ObString &fmt, ObTime &ob_time, int16_t *scale)
 {
   int ret = OB_SUCCESS;
   //  bool is_minus = false;
@@ -2151,10 +2150,10 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
     ret = OB_INVALID_DATE_FORMAT;
     LOG_WARN("datetime format is invalid", K(ret), K(fmt));
   } else {
-    const char* str_pos = str.ptr();
-    const char* str_end = str.ptr() + str.length();
-    const char* fmt_pos = fmt.ptr();
-    const char* fmt_end = fmt.ptr() + fmt.length();
+    const char *str_pos = str.ptr();
+    const char *str_end = str.ptr() + str.length();
+    const char *fmt_pos = fmt.ptr();
+    const char *fmt_end = fmt.ptr() + fmt.length();
     ObString name;
     ObTimeDigits digits;
     ObTimeDelims delims;
@@ -2180,7 +2179,7 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
         }
         switch (*fmt_pos) {
           case 'a': {
-            name.assign_ptr(const_cast<char*>(str_pos), static_cast<int32_t>(str_end - str_pos));
+            name.assign_ptr(const_cast<char *>(str_pos), static_cast<int32_t>(str_end - str_pos));
             if (OB_SUCC(get_str_array_idx(name, WDAY_ABBR_NAMES, DAYS_PER_WEEK, ob_time.parts_[DT_WDAY]))) {
               str_pos += WDAY_ABBR_NAMES[ob_time.parts_[DT_WDAY]].len_;
               week_day_elements.weekday_set_ = true;
@@ -2189,7 +2188,7 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
             break;
           }
           case 'b': {
-            name.assign_ptr(const_cast<char*>(str_pos), static_cast<int32_t>(str_end - str_pos));
+            name.assign_ptr(const_cast<char *>(str_pos), static_cast<int32_t>(str_end - str_pos));
             if (OB_SUCC(get_str_array_idx(
                     name, MON_ABBR_NAMES, static_cast<int32_t>(MONS_PER_YEAR), ob_time.parts_[DT_MON]))) {
               str_pos += MON_ABBR_NAMES[ob_time.parts_[DT_MON]].len_;
@@ -2204,7 +2203,7 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
             break;
           }
           case 'D': {
-            name.assign_ptr(const_cast<char*>(str_pos), static_cast<int32_t>(str_end - str_pos));
+            name.assign_ptr(const_cast<char *>(str_pos), static_cast<int32_t>(str_end - str_pos));
             if (OB_SUCC(get_str_array_idx(name, MDAY_NAMES, static_cast<int32_t>(31), ob_time.parts_[DT_MDAY]))) {
               str_pos += MDAY_NAMES[ob_time.parts_[DT_MDAY]].len_;
             }
@@ -2254,7 +2253,7 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
             break;
           }
           case 'M': {
-            name.assign_ptr(const_cast<char*>(str_pos), static_cast<int32_t>(str_end - str_pos));
+            name.assign_ptr(const_cast<char *>(str_pos), static_cast<int32_t>(str_end - str_pos));
             if (OB_SUCC(
                     get_str_array_idx(name, MON_NAMES, static_cast<int32_t>(MONS_PER_YEAR), ob_time.parts_[DT_MON]))) {
               str_pos += MON_NAMES[ob_time.parts_[DT_MON]].len_;
@@ -2325,8 +2324,8 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
           }
           case 'W': {
             name.assign_ptr(const_cast<char *>(str_pos), static_cast<int32_t>(str_end - str_pos));
-            if (OB_SUCC(get_str_array_idx(name, WDAY_NAMES, static_cast<int32_t>(DAYS_PER_WEEK),
-                        ob_time.parts_[DT_WDAY]))) {
+            if (OB_SUCC(get_str_array_idx(
+                    name, WDAY_NAMES, static_cast<int32_t>(DAYS_PER_WEEK), ob_time.parts_[DT_WDAY]))) {
               str_pos += WDAY_NAMES[ob_time.parts_[DT_WDAY]].len_;
               week_day_elements.weekday_set_ = true;
               week_day_elements.weekday_value_ = ob_time.parts_[DT_WDAY] % DAYS_PER_WEEK;
@@ -2395,8 +2394,7 @@ int ObTimeConverter::str_to_ob_time_format(const ObString& str, const ObString&
       }
       if (OB_FAIL(handle_year_week_wday(week_day_elements, ob_time))) {
         LOG_WARN("handle %u %x %v and %w value failed", K(ret));
-      } else if (0 == ob_time.parts_[DT_MON] && 0 == ob_time.parts_[DT_MDAY]
-                 && 0 == ob_time.parts_[DT_YEAR]) {
+      } else if (0 == ob_time.parts_[DT_MON] && 0 == ob_time.parts_[DT_MDAY] && 0 == ob_time.parts_[DT_YEAR]) {
         if (OB_FAIL(validate_time(ob_time))) {
           LOG_WARN("time value is invalid or out of range", K(ret), K(str));
         }
@@ -2423,16 +2421,16 @@ int ObTimeConverter::calc_date_with_year_week_wday(const ObYearWeekWdayElems &el
   // now we get weekday of %X-01-01: tmp_ot.parts_[DT_WDAY]
   const bool is_sunday_start = elements.is_upper_week_set();
   int32_t week = elements.week_value_;
-  int32_t weekday = is_sunday_start ? elements.weekday_value_
-                    : ((elements.weekday_value_ + DAYS_PER_WEEK - 1) % DAYS_PER_WEEK) + 1;
+  int32_t weekday =
+      is_sunday_start ? elements.weekday_value_ : ((elements.weekday_value_ + DAYS_PER_WEEK - 1) % DAYS_PER_WEEK) + 1;
   // %X%V means week start with sunday and the first week in the year must contain sunday.
   const int32_t first_week_monday_offset_upper[DAYS_PER_WEEK] = {1, 7, 6, 5, 4, 3, 2};
   // %X%V means week start with monday and the first week in the year must contain at least 4 days.
   const int32_t first_week_monday_offset_lower[DAYS_PER_WEEK] = {1, 0, -1, -2, -3, 3, 2};
-  int32_t offset = (elements.is_upper_week_set() ?
-                      first_week_monday_offset_upper[tmp_ot.parts_[DT_WDAY] % DAYS_PER_WEEK] :
-                      first_week_monday_offset_lower[tmp_ot.parts_[DT_WDAY] % DAYS_PER_WEEK])
-                    + (week - 1) * DAYS_PER_WEEK + (weekday - 1);
+  int32_t offset =
+      (elements.is_upper_week_set() ? first_week_monday_offset_upper[tmp_ot.parts_[DT_WDAY] % DAYS_PER_WEEK]
+                                    : first_week_monday_offset_lower[tmp_ot.parts_[DT_WDAY] % DAYS_PER_WEEK]) +
+      (week - 1) * DAYS_PER_WEEK + (weekday - 1);
   int32_t date_value = tmp_ot.parts_[DT_DATE] + offset;
   if (OB_FAIL(date_to_ob_time(date_value, ot))) {
     LOG_WARN("date to ob time failed", K(ret));
@@ -2445,8 +2443,8 @@ int ObTimeConverter::handle_year_week_wday(const ObYearWeekWdayElems &elements,
 {
   int ret = OB_SUCCESS;
   //%X/%x must be used together with %V/%v
-  if ((elements.is_year_set() || elements.is_week_v_set())
-      && !(elements.year_set_state_ == elements.week_set_state_ && elements.is_week_v_set())) {
+  if ((elements.is_year_set() || elements.is_week_v_set()) &&
+      !(elements.year_set_state_ == elements.week_set_state_ && elements.is_week_v_set())) {
     ret = OB_INVALID_DATE_VALUE;
     MEMSET(ot.parts_, 0, sizeof(*ot.parts_) * TOTAL_PART_CNT);
     ot.parts_[DT_DATE] = ZERO_DATE;
@@ -2475,7 +2473,7 @@ int ObTimeConverter::handle_year_week_wday(const ObYearWeekWdayElems &elements,
   return ret;
 }
 
-int ObTimeConverter::str_to_ob_interval(const ObString& str, ObDateUnitType unit_type, ObInterval& ob_interval)
+int ObTimeConverter::str_to_ob_interval(const ObString &str, ObDateUnitType unit_type, ObInterval &ob_interval)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr()) || OB_UNLIKELY(str.length() <= 0)) {
@@ -2486,8 +2484,8 @@ int ObTimeConverter::str_to_ob_interval(const ObString& str, ObDateUnitType unit
       }
     }
   } else {
-    const char* pos = str.ptr();
-    const char* end = pos + str.length();
+    const char *pos = str.ptr();
+    const char *end = pos + str.length();
     if (is_negative(pos, end)) {
       ob_interval.mode_ |= DT_MODE_NEG;
     }
@@ -2547,7 +2545,7 @@ int ObTimeConverter::str_to_ob_interval(const ObString& str, ObDateUnitType unit
   return ret;
 }
 
-int ObTimeConverter::usec_to_ob_time(int64_t usec, ObTime& ob_time)
+int ObTimeConverter::usec_to_ob_time(int64_t usec, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   int32_t days = static_cast<int32_t>(usec / USECS_PER_DAY);
@@ -2564,7 +2562,7 @@ int ObTimeConverter::usec_to_ob_time(int64_t usec, ObTime& ob_time)
   return ret;
 }
 
-int ObTimeConverter::datetime_to_ob_time(int64_t value, const ObTimeZoneInfo* tz_info, ObTime& ob_time)
+int ObTimeConverter::datetime_to_ob_time(int64_t value, const ObTimeZoneInfo *tz_info, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   int64_t usec = value;
@@ -2581,8 +2579,8 @@ int ObTimeConverter::datetime_to_ob_time(int64_t value, const ObTimeZoneInfo* tz
   return ret;
 }
 
-int ObTimeConverter::otimestamp_to_ob_time(const ObObjType type, const ObOTimestampData& ot_data,
-    const ObTimeZoneInfo* tz_info, ObTime& ob_time, const bool store_utc_time /*true*/)
+int ObTimeConverter::otimestamp_to_ob_time(const ObObjType type, const ObOTimestampData &ot_data,
+    const ObTimeZoneInfo *tz_info, ObTime &ob_time, const bool store_utc_time /*true*/)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(!ob_is_otimestamp_type(type))) {
@@ -2651,10 +2649,10 @@ int ObTimeConverter::otimestamp_to_ob_time(const ObObjType type, const ObOTimest
   return ret;
 }
 
-int ObTimeConverter::date_to_ob_time(int32_t value, ObTime& ob_time)
+int ObTimeConverter::date_to_ob_time(int32_t value, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
-  int32_t* parts = ob_time.parts_;
+  int32_t *parts = ob_time.parts_;
   if (!HAS_TYPE_ORACLE(ob_time.mode_) && OB_UNLIKELY(ZERO_DATE == value)) {
     memset(parts, 0, sizeof(*parts) * DATETIME_PART_CNT);
     parts[DT_DATE] = ZERO_DATE;
@@ -2674,7 +2672,7 @@ int ObTimeConverter::date_to_ob_time(int32_t value, ObTime& ob_time)
     parts[DT_YDAY] = days + 1;
     parts[DT_WDAY] = WDAY_OFFSET[value % DAYS_PER_WEEK][EPOCH_WDAY];
     // month.
-    const int32_t* cur_days_until_mon = DAYS_UNTIL_MON[leap_year];
+    const int32_t *cur_days_until_mon = DAYS_UNTIL_MON[leap_year];
     int32_t month = 1;
     for (; month < MONS_PER_YEAR && days >= cur_days_until_mon[month]; ++month) {}
     parts[DT_MON] = month;
@@ -2685,7 +2683,7 @@ int ObTimeConverter::date_to_ob_time(int32_t value, ObTime& ob_time)
   return ret;
 }
 
-int ObTimeConverter::time_to_ob_time(int64_t value, ObTime& ob_time)
+int ObTimeConverter::time_to_ob_time(int64_t value, ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(value < 0)) {
@@ -2724,7 +2722,7 @@ int64_t ObTimeConverter::ob_time_to_int(const ObTime &ob_time, ObDTMode mode)
 
 static const int32_t DT_PART_MUL[DATETIME_PART_CNT] = {100, 100, 100, 100, 100, 1000000, 1};
 static const int64_t ZERO_DATE_WEEK = 613566757;  // for 0000-00-00 00:00:00 .
-int64_t ObTimeConverter::ob_time_to_int_extract(const ObTime& ob_time, ObDateUnitType unit_type)
+int64_t ObTimeConverter::ob_time_to_int_extract(const ObTime &ob_time, ObDateUnitType unit_type)
 {
   int64_t value = 0;
   switch (unit_type) {
@@ -2785,7 +2783,7 @@ int64_t ObTimeConverter::ob_time_to_int_extract(const ObTime& ob_time, ObDateUni
   }
 
 int ObTimeConverter::ob_time_to_str(
-    const ObTime& ob_time, ObDTMode mode, int16_t scale, char* buf, int64_t buf_len, int64_t& pos, bool with_delim)
+    const ObTime &ob_time, ObDTMode mode, int16_t scale, char *buf, int64_t buf_len, int64_t &pos, bool with_delim)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(mode <= 0) || OB_UNLIKELY(scale > (HAS_TYPE_ORACLE(ob_time.mode_) ? 9 : 6)) || OB_ISNULL(buf) ||
@@ -2793,7 +2791,7 @@ int ObTimeConverter::ob_time_to_str(
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("Invalid argument", KP(buf), K(buf_len), K(pos), K(scale), K(mode), K(ret));
   } else {
-    const int32_t* parts = ob_time.parts_;
+    const int32_t *parts = ob_time.parts_;
     if (HAS_TYPE_DATE(mode)) {
       if (OB_UNLIKELY(parts[DT_YEAR] > 9999) || OB_UNLIKELY(parts[DT_YEAR] < 0) || OB_UNLIKELY(parts[DT_MON] > 12) ||
           OB_UNLIKELY(parts[DT_MON] < 0) || OB_UNLIKELY(parts[DT_MDAY] > 31) || OB_UNLIKELY(parts[DT_MDAY] < 0)) {
@@ -2805,7 +2803,7 @@ int ObTimeConverter::ob_time_to_str(
         LOG_WARN("Unexpected time", K(ret), K(parts[DT_YEAR]), K(parts[DT_MON]), K(parts[DT_MDAY]));
       } else if (OB_LIKELY(with_delim && (buf_len - pos) > 10)        // format 0000-00-00
                  || OB_LIKELY(!with_delim && (buf_len - pos) > 8)) {  // format yyyymmdd
-        char* buf_t = buf + pos;
+        char *buf_t = buf + pos;
         // deal year.year[0000-9999]
         int32_t high = parts[DT_YEAR] / 100;
         int32_t low = parts[DT_YEAR] - high * 100;
@@ -2848,7 +2846,7 @@ int ObTimeConverter::ob_time_to_str(
         LOG_WARN("Unexpected hour", K(parts[DT_HOUR]), K(parts[DT_MIN]), K(parts[DT_SEC]), K(ret));
       } else if (OB_LIKELY(with_delim && (buf_len - pos) > 9)         // format 00:00:00 and hour may 3 digit
                  || OB_LIKELY(!with_delim && (buf_len - pos) > 7)) {  // format hhmmss and hour may 3 digit
-        char* buf_t = buf + pos;
+        char *buf_t = buf + pos;
         PRINTF_2D_WITH_THREE_DIGIT(buf_t, parts[DT_HOUR]);
         if (with_delim) {
           *buf_t++ = ':';
@@ -2944,7 +2942,7 @@ int ObTimeConverter::ob_time_to_str(
           } else if (OB_LIKELY(with_delim && (buf_len - pos) > 6)) {  // format 00:00 and hour may 3 digit
             int32_t offset_hour = static_cast<int32_t>(dt_offset_min / MINS_PER_HOUR);
             int32_t offset_min = static_cast<int32_t>(dt_offset_min % MINS_PER_HOUR);
-            char* buf_t = buf + pos;
+            char *buf_t = buf + pos;
             PRINTF_2D_WITH_THREE_DIGIT(buf_t, offset_hour);
             if (with_delim) {
               *buf_t++ = ':';
@@ -2970,7 +2968,7 @@ int ObTimeConverter::ob_time_to_str(
 }
 
 int ObTimeConverter::get_day_and_month_from_year_day(
-    const int32_t yday, const int32_t year, int32_t& month, int32_t& day)
+    const int32_t yday, const int32_t year, int32_t &month, int32_t &day)
 {
   int ret = OB_SUCCESS;
   int32_t leap_year = IS_LEAP_YEAR(year);
@@ -3000,7 +2998,7 @@ int32_t ObTimeConverter::calc_max_name_length(const ObTimeConstStr names[], cons
   return res;
 }
 
-int ObTimeConverter::data_fmt_nd(char* buffer, int64_t buf_len, int64_t& pos, const int64_t n, int64_t target)
+int ObTimeConverter::data_fmt_nd(char *buffer, int64_t buf_len, int64_t &pos, const int64_t n, int64_t target)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(n <= 0 || target < 0 || target > 999999999)) {
@@ -3023,14 +3021,14 @@ int ObTimeConverter::data_fmt_nd(char* buffer, int64_t buf_len, int64_t& pos, co
   return ret;
 }
 
-int ObTimeConverter::data_fmt_d(char* buffer, int64_t buf_len, int64_t& pos, int64_t target)
+int ObTimeConverter::data_fmt_d(char *buffer, int64_t buf_len, int64_t &pos, int64_t target)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(target < 0)) {
     ret = OB_ERR_UNEXPECTED;
     LIB_TIME_LOG(ERROR, "invalid argument", K(ret), K(target));
   } else {
-    //buffer_size_need will be 1 or 2 or 3
+    // buffer_size_need will be 1 or 2 or 3
     int64_t buffer_size_need = 1 + (target >= 10) + (target >= 100);
     if (OB_UNLIKELY(buffer_size_need > buf_len - pos)) {
       ret = OB_SIZE_OVERFLOW;
@@ -3050,7 +3048,7 @@ int ObTimeConverter::data_fmt_d(char* buffer, int64_t buf_len, int64_t& pos, int
   return ret;
 }
 
-int ObTimeConverter::data_fmt_s(char* buffer, int64_t buf_len, int64_t& pos, const char* ptr)
+int ObTimeConverter::data_fmt_s(char *buffer, int64_t buf_len, int64_t &pos, const char *ptr)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(ptr)) {
@@ -3082,8 +3080,8 @@ int ObTimeConverter::data_fmt_s(char* buffer, int64_t buf_len, int64_t& pos, con
  * @param out:  scale                scale of fractional seconds
  * @return OER
  */
-int ObTimeConverter::str_to_ob_time_oracle_strict(const ObString& str, const ObTimeConvertCtx& cvrt_ctx,
-    const bool is_timestamp_literal, ObTime& ob_time, ObScale& scale)
+int ObTimeConverter::str_to_ob_time_oracle_strict(const ObString &str, const ObTimeConvertCtx &cvrt_ctx,
+    const bool is_timestamp_literal, ObTime &ob_time, ObScale &scale)
 {
   int ret = OB_SUCCESS;
   ObDFMParseCtx ctx(str.ptr(), str.length());
@@ -3283,10 +3281,10 @@ int ObTimeConverter::str_to_ob_time_oracle_strict(const ObString& str, const ObT
  * @param out:  scale       scale of fractional seconds
  */
 int ObTimeConverter::str_to_ob_time_oracle_dfm(
-    const ObString& str, const ObTimeConvertCtx& cvrt_ctx, const ObObjType target_type, ObTime& ob_time, ObScale& scale)
+    const ObString &str, const ObTimeConvertCtx &cvrt_ctx, const ObObjType target_type, ObTime &ob_time, ObScale &scale)
 {
   int ret = OB_SUCCESS;
-  const ObString& format = cvrt_ctx.oracle_nls_format_;
+  const ObString &format = cvrt_ctx.oracle_nls_format_;
   if (OB_UNLIKELY(
           str.empty() || format.empty() || (!ob_is_otimestamp_type(target_type) && !ob_is_datetime_tc(target_type)))) {
     ret = OB_INVALID_ARGUMENT;
@@ -3330,8 +3328,12 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
       if (OB_ISNULL(cvrt_ctx.tz_info_)) {
         ret = OB_ERR_UNEXPECTED;
         LOG_WARN("session timezone info is null", K(ret));
-      } else if (sub_timezone_offset(*(cvrt_ctx.tz_info_), ObString(),
-                                     utc_curr_time_copy, session_tz_offset, session_tz_id, session_tran_type_id)) {
+      } else if (sub_timezone_offset(*(cvrt_ctx.tz_info_),
+                     ObString(),
+                     utc_curr_time_copy,
+                     session_tz_offset,
+                     session_tz_id,
+                     session_tran_type_id)) {
         LOG_WARN("get session timezone offset failed", K(ret));
       } else if (OB_FAIL(datetime_to_date(utc_curr_time, cvrt_ctx.tz_info_, cur_date))) {
         LOG_WARN("timestamp to date failed", K(ret));
@@ -3381,7 +3383,7 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
       int64_t ignore_fs_flag = false;
 
       for (elem_idx = 0; OB_SUCC(ret) && elem_idx < dfm_elems.count(); ++elem_idx) {
-        ObDFMElem& elem = dfm_elems.at(elem_idx);
+        ObDFMElem &elem = dfm_elems.at(elem_idx);
         if (OB_UNLIKELY(!elem.is_valid())) {
           ret = OB_ERR_UNEXPECTED;
           LOG_WARN("element is invalid", K(ret), K(elem));
@@ -3458,7 +3460,7 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
             case ObDFMFlag::DAY: {  // TODO : NLS_LANGUAGE NLS_TERRITORIES
               int32_t wday = 0;
               for (wday = 1; wday <= DAYS_PER_WEEK; ++wday) {
-                const ObTimeConstStr& day_str =
+                const ObTimeConstStr &day_str =
                     (elem.elem_flag_ == ObDFMFlag::DAY) ? WDAY_NAMES[wday] : WDAY_ABBR_NAMES[wday];
                 if (ObDFMUtil::match_pattern_ignore_case(ctx, day_str)) {
                   parsed_elem_len = day_str.len_;
@@ -3609,7 +3611,7 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
                     // do nothing
                   } else {
                     ObDFMParseCtx local_ctx(digits_timezone.ptr(), digits_timezone.length());
-                    const char* local_sep = ObDFMUtil::find_first_separator(local_ctx);
+                    const char *local_sep = ObDFMUtil::find_first_separator(local_ctx);
 
                     if (OB_ISNULL(local_sep)) {
                       // timezone offset string is allowd to contain only hour part.
@@ -3771,7 +3773,7 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
             case ObDFMFlag::MONTH: {
               int32_t mon = 0;
               for (mon = ObDFMLimit::MONTH.MIN; mon <= ObDFMLimit::MONTH.MAX; ++mon) {
-                const ObTimeConstStr& mon_str =
+                const ObTimeConstStr &mon_str =
                     (elem.elem_flag_ == ObDFMFlag::MONTH) ? MON_NAMES[mon] : MON_ABBR_NAMES[mon];
                 if (ObDFMUtil::match_pattern_ignore_case(ctx, mon_str)) {
                   parsed_elem_len = mon_str.len_;
@@ -4139,7 +4141,7 @@ int ObTimeConverter::str_to_ob_time_oracle_dfm(
   return ret;
 }
 // check parts of obtime before print timestamp in oracle mode
-bool ObTimeConverter::valid_oracle_year(const ObTime& ob_time)
+bool ObTimeConverter::valid_oracle_year(const ObTime &ob_time)
 {
   int ret = true;
   if (ob_time.parts_[DT_YEAR] < 0 || ob_time.parts_[DT_YEAR] > 9999) {
@@ -4149,7 +4151,7 @@ bool ObTimeConverter::valid_oracle_year(const ObTime& ob_time)
 }
 
 int ObTimeConverter::ob_time_to_str_oracle_dfm(
-    const ObTime& ob_time, ObScale scale, const ObString& format, char* buf, int64_t buf_len, int64_t& pos)
+    const ObTime &ob_time, ObScale scale, const ObString &format, char *buf, int64_t buf_len, int64_t &pos)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(buf) || OB_UNLIKELY(buf_len <= 0) || OB_UNLIKELY(format.empty()) ||
@@ -4175,7 +4177,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
       }
     };
 
-    const char* const format_begin_ptr = format.ptr();
+    const char *const format_begin_ptr = format.ptr();
     int64_t last_elem_end_pos = 0;
     ObSEArray<ObDFMElem, ObDFMUtil::COMMON_ELEMENT_NUMBER> dfm_elems;
 
@@ -4186,7 +4188,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
 
     // 2. print each element
     for (int64_t i = 0; OB_SUCC(ret) && i < dfm_elems.count(); ++i) {
-      ObDFMElem& elem = dfm_elems.at(i);
+      ObDFMElem &elem = dfm_elems.at(i);
 
       // element is valid
       if (OB_UNLIKELY(!elem.is_valid())) {
@@ -4213,14 +4215,14 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
         switch (elem.elem_flag_) {
           case ObDFMFlag::AD:
           case ObDFMFlag::BC: {  // TODO : NLS_LANGUAGE
-            const ObTimeConstStr& target_str =
+            const ObTimeConstStr &target_str =
                 ob_time.parts_[DT_YEAR] > 0 ? ObDFMFlag::PATTERN[ObDFMFlag::AD] : ObDFMFlag::PATTERN[ObDFMFlag::BC];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, target_str, elem.upper_case_mode_);
             break;
           }
           case ObDFMFlag::AD2:
           case ObDFMFlag::BC2: {  // TODO : NLS_LANGUAGE
-            const ObTimeConstStr& str =
+            const ObTimeConstStr &str =
                 ob_time.parts_[DT_YEAR] > 0 ? ObDFMFlag::PATTERN[ObDFMFlag::AD2] : ObDFMFlag::PATTERN[ObDFMFlag::BC2];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, str, elem.upper_case_mode_);
             break;
@@ -4239,7 +4241,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             break;
           }
           case ObDFMFlag::DAY: {  // TODO : NLS_LANGUAGE
-            const ObTimeConstStr& day_str = WDAY_NAMES[ob_time.parts_[DT_WDAY]];
+            const ObTimeConstStr &day_str = WDAY_NAMES[ob_time.parts_[DT_WDAY]];
             ret = ObDFMUtil::special_mode_sprintf(
                 buf, buf_len, pos, day_str, elem.upper_case_mode_, MAX_WDAY_NAME_LENGTH);
             break;
@@ -4253,7 +4255,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             break;
           }
           case ObDFMFlag::DY: {  // TODO: 1. NLS_LANGUAGE
-            const ObTimeConstStr& day_str = WDAY_ABBR_NAMES[ob_time.parts_[DT_WDAY]];
+            const ObTimeConstStr &day_str = WDAY_ABBR_NAMES[ob_time.parts_[DT_WDAY]];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, day_str, elem.upper_case_mode_);
             break;
           }
@@ -4268,8 +4270,8 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             break;
           }
           case ObDFMFlag::DL: {  // TODO: 1. NLS_DATE_FORMAT 2. NLS_TERRITORY 3. NLS_LANGUAGE
-            const ObTimeConstStr& wday_str = WDAY_NAMES[ob_time.parts_[DT_WDAY]];
-            const ObTimeConstStr& mon_str = MON_NAMES[ob_time.parts_[DT_MON]];
+            const ObTimeConstStr &wday_str = WDAY_NAMES[ob_time.parts_[DT_WDAY]];
+            const ObTimeConstStr &mon_str = MON_NAMES[ob_time.parts_[DT_MON]];
             ret = databuff_printf(buf,
                 buf_len,
                 pos,
@@ -4356,26 +4358,26 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             break;
           }
           case ObDFMFlag::MONTH: {
-            const ObTimeConstStr& mon_str = MON_NAMES[ob_time.parts_[DT_MON]];
+            const ObTimeConstStr &mon_str = MON_NAMES[ob_time.parts_[DT_MON]];
             ret =
                 ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, mon_str, elem.upper_case_mode_, MAX_MON_NAME_LENGTH);
             break;
           }
           case ObDFMFlag::MON: {
-            const ObTimeConstStr& mon_str = MON_ABBR_NAMES[ob_time.parts_[DT_MON]];
+            const ObTimeConstStr &mon_str = MON_ABBR_NAMES[ob_time.parts_[DT_MON]];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, mon_str, elem.upper_case_mode_);
             break;
           }
           case ObDFMFlag::AM:
           case ObDFMFlag::PM: {
-            const ObTimeConstStr& str =
+            const ObTimeConstStr &str =
                 ob_time.parts_[DT_HOUR] >= 12 ? ObDFMFlag::PATTERN[ObDFMFlag::PM] : ObDFMFlag::PATTERN[ObDFMFlag::AM];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, str, elem.upper_case_mode_);
             break;
           }
           case ObDFMFlag::AM2:
           case ObDFMFlag::PM2: {
-            const ObTimeConstStr& str =
+            const ObTimeConstStr &str =
                 ob_time.parts_[DT_HOUR] >= 12 ? ObDFMFlag::PATTERN[ObDFMFlag::PM2] : ObDFMFlag::PATTERN[ObDFMFlag::AM2];
             ret = ObDFMUtil::special_mode_sprintf(buf, buf_len, pos, str, elem.upper_case_mode_);
             break;
@@ -4426,7 +4428,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             break;
           }
           case ObDFMFlag::SYYYY: {
-            const char* fmt_str = ob_time.parts_[DT_YEAR] < 0 ? "-%04d" : " %04d";
+            const char *fmt_str = ob_time.parts_[DT_YEAR] < 0 ? "-%04d" : " %04d";
             ret = databuff_printf(buf, buf_len, pos, fmt_str, abs(ob_time.parts_[DT_YEAR]));
             break;
           }
@@ -4484,7 +4486,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
               ret = databuff_printf(
                   buf, buf_len, pos, "%.*s", ob_time.get_tz_name_str().length(), ob_time.get_tz_name_str().ptr());
             } else {
-              const char* fmt_str = ob_time.parts_[DT_OFFSET_MIN] < 0 ? "-%02d:%02d" : "+%02d:%02d";
+              const char *fmt_str = ob_time.parts_[DT_OFFSET_MIN] < 0 ? "-%02d:%02d" : "+%02d:%02d";
               ret = databuff_printf(buf,
                   buf_len,
                   pos,
@@ -4498,7 +4500,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
             if (OB_UNLIKELY(!HAS_TYPE_TIMEZONE(ob_time.mode_))) {
               ret = OB_INVALID_DATE_FORMAT;
             } else {
-              const char* fmt_str = ob_time.parts_[DT_OFFSET_MIN] < 0 ? "-%02d" : "+%02d";
+              const char *fmt_str = ob_time.parts_[DT_OFFSET_MIN] < 0 ? "-%02d" : "+%02d";
               ret = databuff_printf(buf, buf_len, pos, fmt_str, abs(ob_time.parts_[DT_OFFSET_MIN]) / 60);
             }
             break;
@@ -4553,7 +4555,7 @@ int ObTimeConverter::ob_time_to_str_oracle_dfm(
   return ret;
 }
 
-int ObTimeConverter::deduce_max_len_from_oracle_dfm(const ObString& format, int64_t& max_char_len)
+int ObTimeConverter::deduce_max_len_from_oracle_dfm(const ObString &format, int64_t &max_char_len)
 {
   int ret = OB_SUCCESS;
   max_char_len = 0;
@@ -4564,7 +4566,7 @@ int ObTimeConverter::deduce_max_len_from_oracle_dfm(const ObString& format, int6
     LOG_WARN("format is empty", K(ret));
   }
   if (OB_SUCC(ret)) {
-    const char* const format_begin_ptr = format.ptr();
+    const char *const format_begin_ptr = format.ptr();
     int64_t last_elem_end_pos = 0;
     ObSEArray<ObDFMElem, ObDFMUtil::COMMON_ELEMENT_NUMBER> dfm_elems;
     // Parse elements from format string
@@ -4573,7 +4575,7 @@ int ObTimeConverter::deduce_max_len_from_oracle_dfm(const ObString& format, int6
     }
     // accumulate max length for each element
     for (int i = 0; OB_SUCC(ret) && i < dfm_elems.count(); ++i) {
-      ObDFMElem& elem = dfm_elems.at(i);
+      ObDFMElem &elem = dfm_elems.at(i);
       if (OB_UNLIKELY(!elem.is_valid())) {
         ret = OB_ERR_UNEXPECTED;
         LOG_WARN("elem is invalid", K(ret), K(elem));
@@ -4611,16 +4613,16 @@ int ObTimeConverter::deduce_max_len_from_oracle_dfm(const ObString& format, int6
 }
 
 int ObTimeConverter::ob_time_to_str_format(
-    const ObTime& ob_time, const ObString& format, char* buf, int64_t buf_len, int64_t& pos, bool& res_null)
+    const ObTime &ob_time, const ObString &format, char *buf, int64_t buf_len, int64_t &pos, bool &res_null)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(format.ptr()) || OB_ISNULL(buf) || OB_UNLIKELY(format.length() <= 0 || buf_len <= 0)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("format or output string is invalid", K(ret), K(format), K(buf), K(buf_len));
   } else {
-    const char* format_ptr = format.ptr();
-    const char* end_ptr = format.ptr() + format.length();
-    const int32_t* parts = ob_time.parts_;
+    const char *format_ptr = format.ptr();
+    const char *end_ptr = format.ptr() + format.length();
+    const int32_t *parts = ob_time.parts_;
     int32_t week_sunday = -1;
     int32_t week_monday = -1;
     int32_t delta_sunday = -2;
@@ -4720,13 +4722,13 @@ int ObTimeConverter::ob_time_to_str_format(
             break;
           }
           case 'p': {  // AM or PM
-            const char* ptr = parts[DT_HOUR] < 12 ? "AM" : "PM";
+            const char *ptr = parts[DT_HOUR] < 12 ? "AM" : "PM";
             ret = data_fmt_s(buf, buf_len, pos, ptr);
             break;
           }
           case 'r': {  // Time, 12-hour (hh:mm:ss followed by AM or PM)
             int hour = hour_converter[parts[DT_HOUR]];
-            const char* ptr = parts[DT_HOUR] < 12 ? "AM" : "PM";
+            const char *ptr = parts[DT_HOUR] < 12 ? "AM" : "PM";
             ret = databuff_printf(buf, buf_len, pos, "%02d:%02d:%02d %s", hour, parts[DT_MIN], parts[DT_SEC], ptr);
             break;
           }
@@ -4840,11 +4842,11 @@ int ObTimeConverter::ob_time_to_str_format(
   return ret;
 }
 
-int check_and_get_tz_info(ObTime& ob_time, const ObTimeConvertCtx& cvrt_ctx, const ObTimeZoneInfo*& tz_info,
-    ObTimeZoneInfoPos*& literal_tz_info, ObTZInfoIDPosMap*& tz_id_pos_map)
+int check_and_get_tz_info(ObTime &ob_time, const ObTimeConvertCtx &cvrt_ctx, const ObTimeZoneInfo *&tz_info,
+    ObTimeZoneInfoPos *&literal_tz_info, ObTZInfoIDPosMap *&tz_id_pos_map)
 {
   int ret = OB_SUCCESS;
-  ObTZInfoMap* tz_info_map = NULL;
+  ObTZInfoMap *tz_info_map = NULL;
   if (OB_UNLIKELY(ob_time.is_tz_name_valid_)) {  // use string literal tz_inifo
     // tz_info_ is expected to be not null, but sometimes we don't set it.
     if (NULL == cvrt_ctx.tz_info_) {
@@ -4852,7 +4854,7 @@ int check_and_get_tz_info(ObTime& ob_time, const ObTimeConvertCtx& cvrt_ctx, con
         ret = OB_INVALID_ARGUMENT;
         LOG_WARN("tz_info_ is NULL", K(ret));
       }
-    } else if (OB_ISNULL(tz_info_map = const_cast<ObTZInfoMap*>(cvrt_ctx.tz_info_->get_tz_info_map()))) {
+    } else if (OB_ISNULL(tz_info_map = const_cast<ObTZInfoMap *>(cvrt_ctx.tz_info_->get_tz_info_map()))) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("tz_info_map is NULL", K(ret));
     } else if (OB_FAIL(tz_info_map->get_tz_info_by_name(ob_time.get_tz_name_str(), literal_tz_info))) {
@@ -4870,7 +4872,7 @@ int check_and_get_tz_info(ObTime& ob_time, const ObTimeConvertCtx& cvrt_ctx, con
   return ret;
 }
 
-int ObTimeConverter::ob_time_to_datetime(ObTime& ob_time, const ObTimeConvertCtx& cvrt_ctx, int64_t& value)
+int ObTimeConverter::ob_time_to_datetime(ObTime &ob_time, const ObTimeConvertCtx &cvrt_ctx, int64_t &value)
 {
   int ret = OB_SUCCESS;
   if (ZERO_DATE == ob_time.parts_[DT_DATE]) {
@@ -4879,9 +4881,9 @@ int ObTimeConverter::ob_time_to_datetime(ObTime& ob_time, const ObTimeConvertCtx
     // there is no leap second, and the valid range of datetime and timestamp is not same as mysql.
     // so we don't handle leap second and shift things, delete all related codes.
     int64_t usec = ob_time.parts_[DT_DATE] * USECS_PER_DAY + ob_time_to_time(ob_time);
-    const ObTimeZoneInfo* tz_info = NULL;
-    ObTimeZoneInfoPos* literal_tz_info = NULL;
-    ObTZInfoIDPosMap* tz_id_pos_map = NULL;
+    const ObTimeZoneInfo *tz_info = NULL;
+    ObTimeZoneInfoPos *literal_tz_info = NULL;
+    ObTZInfoIDPosMap *tz_id_pos_map = NULL;
     if (usec > DATETIME_MAX_VAL || usec < DATETIME_MIN_VAL) {
       ret = OB_DATETIME_FUNCTION_OVERFLOW;
       LOG_WARN("datetime filed overflow", K(ret), K(usec));
@@ -4903,7 +4905,7 @@ int ObTimeConverter::ob_time_to_datetime(ObTime& ob_time, const ObTimeConvertCtx
   return ret;
 }
 
-int ObTimeConverter::ob_time_to_otimestamp(ObTime& ob_time, ObOTimestampData& value)
+int ObTimeConverter::ob_time_to_otimestamp(ObTime &ob_time, ObOTimestampData &value)
 {
   int ret = OB_SUCCESS;
   if (!HAS_TYPE_ORACLE(ob_time.mode_)) {
@@ -4939,13 +4941,13 @@ int ObTimeConverter::ob_time_to_otimestamp(ObTime& ob_time, ObOTimestampData& va
  *  B and D is the rest part (month and day), both >= 0.
  */
 
-int32_t ObTimeConverter::ob_time_to_date(ObTime& ob_time)
+int32_t ObTimeConverter::ob_time_to_date(ObTime &ob_time)
 {
   int32_t value = 0;
   if (ZERO_DATE == ob_time.parts_[DT_DATE] && !HAS_TYPE_ORACLE(ob_time.mode_)) {
     value = ZERO_DATE;
   } else {
-    int32_t* parts = ob_time.parts_;
+    int32_t *parts = ob_time.parts_;
     parts[DT_YDAY] = DAYS_UNTIL_MON[IS_LEAP_YEAR(parts[DT_YEAR])][parts[DT_MON] - 1] + parts[DT_MDAY];
     int32_t days_of_years = (parts[DT_YEAR] - EPOCH_YEAR4) * DAYS_PER_NYEAR;
     int32_t leap_year_count = LEAP_YEAR_COUNT(parts[DT_YEAR] - 1) - LEAP_YEAR_COUNT(EPOCH_YEAR4 - 1);
@@ -4955,21 +4957,21 @@ int32_t ObTimeConverter::ob_time_to_date(ObTime& ob_time)
   return value;
 }
 
-int64_t ObTimeConverter::ob_time_to_time(const ObTime& ob_time)
+int64_t ObTimeConverter::ob_time_to_time(const ObTime &ob_time)
 {
   return ((ob_time.parts_[DT_HOUR] * MINS_PER_HOUR + ob_time.parts_[DT_MIN]) * SECS_PER_MIN + ob_time.parts_[DT_SEC]) *
              USECS_PER_SEC +
          (HAS_TYPE_ORACLE(ob_time.mode_) ? ob_time.parts_[DT_USEC] / NSECS_PER_USEC : ob_time.parts_[DT_USEC]);
 }
 
-int ObTimeConverter::ob_interval_to_interval(const ObInterval& ob_interval, int64_t& value)
+int ObTimeConverter::ob_interval_to_interval(const ObInterval &ob_interval, int64_t &value)
 {
   int ret = OB_SUCCESS;
   if (ob_interval.parts_[DT_YEAR] > 0 || ob_interval.parts_[DT_MON] > 0) {
     ret = OB_INTERVAL_WITH_MONTH;
     LOG_WARN("Interval with year or month can't be converted to useconds", K(ret));
   } else {
-    const int32_t* parts = ob_interval.parts_;
+    const int32_t *parts = ob_interval.parts_;
     value = 0;
     for (int32_t i = DT_MDAY; i <= DT_USEC; ++i) {
       value *= DT_PART_BASE[i];
@@ -4982,15 +4984,15 @@ int ObTimeConverter::ob_interval_to_interval(const ObInterval& ob_interval, int6
   return ret;
 }
 
-int32_t ObTimeConverter::ob_time_to_week(const ObTime& ob_time, ObDTMode mode)
+int32_t ObTimeConverter::ob_time_to_week(const ObTime &ob_time, ObDTMode mode)
 {
   int32_t temp = 0;  // trivial parameter.adapted for ob_time_to_week(const ObTime &, ObDTMode , int32_t)
   return ob_time_to_week(ob_time, mode, temp);
 }
 
-int32_t ObTimeConverter::ob_time_to_week(const ObTime& ob_time, ObDTMode mode, int32_t& delta)
+int32_t ObTimeConverter::ob_time_to_week(const ObTime &ob_time, ObDTMode mode, int32_t &delta)
 {
-  const int32_t* parts = ob_time.parts_;
+  const int32_t *parts = ob_time.parts_;
   int32_t is_sun_begin = IS_SUN_BEGIN(mode);
   int32_t is_zero_begin = IS_ZERO_BEGIN(mode);
   int32_t is_ge_4_begin = IS_GE_4_BEGIN(mode);
@@ -5025,9 +5027,9 @@ int32_t ObTimeConverter::ob_time_to_week(const ObTime& ob_time, ObDTMode mode, i
 ////////////////////////////////
 // below are other utility functions:
 
-int ObTimeConverter::validate_datetime(ObTime& ob_time, const bool is_dayofmonth)
+int ObTimeConverter::validate_datetime(ObTime &ob_time, const bool is_dayofmonth)
 {
-  const int32_t* parts = ob_time.parts_;
+  const int32_t *parts = ob_time.parts_;
   int ret = OB_SUCCESS;
   if (!HAS_TYPE_ORACLE(ob_time.mode_) && !is_dayofmonth && OB_UNLIKELY(0 == parts[DT_MON] && 0 == parts[DT_MDAY])) {
     if (!(0 == parts[DT_YEAR] && 0 == parts[DT_HOUR] && 0 == parts[DT_MIN] && 0 == parts[DT_SEC] &&
@@ -5037,8 +5039,8 @@ int ObTimeConverter::validate_datetime(ObTime& ob_time, const bool is_dayofmonth
       ob_time.parts_[DT_DATE] = ZERO_DATE;
     }
   } else {
-    const int64_t* part_min = (HAS_TYPE_ORACLE(ob_time.mode_) ? TZ_PART_MIN : DT_PART_MIN);
-    const int64_t* part_max = (HAS_TYPE_ORACLE(ob_time.mode_) ? TZ_PART_MAX : DT_PART_MAX);
+    const int64_t *part_min = (HAS_TYPE_ORACLE(ob_time.mode_) ? TZ_PART_MIN : DT_PART_MIN);
+    const int64_t *part_max = (HAS_TYPE_ORACLE(ob_time.mode_) ? TZ_PART_MAX : DT_PART_MAX);
     for (int i = 0; OB_SUCC(ret) && i < DATETIME_PART_CNT; ++i) {
       if (is_dayofmonth && (DT_MON == i || DT_MDAY == i) && 0 == parts[i]) {
         /* do nothing */
@@ -5058,9 +5060,9 @@ int ObTimeConverter::validate_datetime(ObTime& ob_time, const bool is_dayofmonth
   return ret;
 }
 
-int ObTimeConverter::validate_oracle_timestamp(const ObTime& ob_time)
+int ObTimeConverter::validate_oracle_timestamp(const ObTime &ob_time)
 {
-  const int32_t* parts = ob_time.parts_;
+  const int32_t *parts = ob_time.parts_;
   int ret = OB_SUCCESS;
   for (int i = 0; OB_SUCC(ret) && i < DATETIME_PART_CNT; ++i) {
     if (parts[i] < TZ_PART_MIN[i] || parts[i] > TZ_PART_MAX[i]) {
@@ -5087,9 +5089,9 @@ int ObTimeConverter::validate_oracle_timestamp(const ObTime& ob_time)
   return ret;
 }
 
-int ObTimeConverter::validate_oracle_date(const ObTime& ob_time)
+int ObTimeConverter::validate_oracle_date(const ObTime &ob_time)
 {
-  const int32_t* parts = ob_time.parts_;
+  const int32_t *parts = ob_time.parts_;
   int ret = OB_SUCCESS;
   for (int i = 0; OB_SUCC(ret) && i < ORACLE_DATE_PART_CNT; ++i) {
     if (parts[i] < TZ_PART_MIN[i] || parts[i] > TZ_PART_MAX[i]) {
@@ -5105,7 +5107,7 @@ int ObTimeConverter::validate_oracle_date(const ObTime& ob_time)
   return ret;
 }
 
-int ObTimeConverter::validate_basic_part_of_ob_time_oracle(const ObTime& ob_time)
+int ObTimeConverter::validate_basic_part_of_ob_time_oracle(const ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   for (int i = 0; OB_SUCC(ret) && i < DATETIME_PART_CNT; ++i) {
@@ -5123,7 +5125,7 @@ int ObTimeConverter::validate_basic_part_of_ob_time_oracle(const ObTime& ob_time
   return ret;
 }
 
-int ObTimeConverter::validate_tz_part_of_ob_time_oracle(const ObTime& ob_time)
+int ObTimeConverter::validate_tz_part_of_ob_time_oracle(const ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   if (OB_INVALID_INDEX != ob_time.time_zone_id_) {
@@ -5137,10 +5139,10 @@ int ObTimeConverter::validate_tz_part_of_ob_time_oracle(const ObTime& ob_time)
   return ret;
 }
 
-int ObTimeConverter::validate_time(ObTime& ob_time)
+int ObTimeConverter::validate_time(ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
-  int32_t* parts = ob_time.parts_;
+  int32_t *parts = ob_time.parts_;
   if (parts[DT_MDAY] > 0) {
     if (parts[DT_MDAY] * HOURS_PER_DAY + parts[DT_HOUR] > INT32_MAX) {
       parts[DT_HOUR] = TIME_MAX_HOUR + 1;
@@ -5174,7 +5176,7 @@ OB_INLINE int ObTimeConverter::validate_year(int64_t year)
 }
 
 int ObTimeConverter::set_ob_time_part_directly(
-    ObTime& ob_time, int64_t& conflict_bitset, const int64_t part_offset, const int32_t part_value)
+    ObTime &ob_time, int64_t &conflict_bitset, const int64_t part_offset, const int32_t part_value)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(part_offset >= TOTAL_PART_CNT)) {
@@ -5194,7 +5196,7 @@ int ObTimeConverter::set_ob_time_part_directly(
  * while call this function, the part_value must be the final value
  */
 int ObTimeConverter::set_ob_time_part_may_conflict(
-    ObTime& ob_time, int64_t& conflict_bitset, const int64_t part_offset, const int32_t part_value)
+    ObTime &ob_time, int64_t &conflict_bitset, const int64_t part_offset, const int32_t part_value)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(part_offset >= TOTAL_PART_CNT)) {
@@ -5218,7 +5220,7 @@ int ObTimeConverter::set_ob_time_part_may_conflict(
 
 // Not set DT_YEAR with set_ob_time_part_may_conflict, reason:
 int ObTimeConverter::set_ob_time_year_may_conflict(
-    ObTime& ob_time, int32_t& julian_year_value, int32_t check_year, int32_t set_year, bool overwrite)
+    ObTime &ob_time, int32_t &julian_year_value, int32_t check_year, int32_t set_year, bool overwrite)
 {
   int ret = OB_SUCCESS;
   if (ZERO_DATE != julian_year_value) {
@@ -5235,7 +5237,7 @@ int ObTimeConverter::set_ob_time_year_may_conflict(
   return ret;
 }
 
-int ObTimeConverter::time_overflow_trunc(int64_t& value)
+int ObTimeConverter::time_overflow_trunc(int64_t &value)
 {
   int ret = OB_SUCCESS;
   if (value > TIME_MAX_VAL) {
@@ -5311,15 +5313,15 @@ int ObTimeConverter::time_overflow_trunc(int64_t& value)
 //  return ret;
 //}
 
-int ObTimeConverter::get_datetime_digits(const char*& str, const char* end, int32_t max_len, ObTimeDigits& digits)
+int ObTimeConverter::get_datetime_digits(const char *&str, const char *end, int32_t max_len, ObTimeDigits &digits)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str) || OB_ISNULL(end) || OB_UNLIKELY(str > end || max_len <= 0)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("str or end or max_len is invalid", K(ret), K(str), K(end), K(max_len));
   } else {
-    const char* pos = str;
-    const char* digit_end = str + max_len < end ? str + max_len : end;
+    const char *pos = str;
+    const char *digit_end = str + max_len < end ? str + max_len : end;
     int32_t value = 0;
     for (; OB_SUCC(ret) && pos < digit_end && isdigit(*pos); ++pos) {
       if (value * 10LL > INT32_MAX - (*pos - '0')) {
@@ -5337,14 +5339,14 @@ int ObTimeConverter::get_datetime_digits(const char*& str, const char* end, int3
   return ret;
 }
 
-int ObTimeConverter::get_datetime_delims(const char*& str, const char* end, ObTimeDelims& delims)
+int ObTimeConverter::get_datetime_delims(const char *&str, const char *end, ObTimeDelims &delims)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str) || OB_ISNULL(end) || OB_UNLIKELY(str > end)) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("str or end or max_len is invalid", K(ret), K(str), K(end));
   } else {
-    const char* pos = str;
+    const char *pos = str;
     for (; pos < end && !isdigit(*pos); ++pos) {}
     delims.ptr_ = str;
     delims.len_ = static_cast<int32_t>(pos - str);
@@ -5354,7 +5356,7 @@ int ObTimeConverter::get_datetime_delims(const char*& str, const char* end, ObTi
 }
 
 OB_INLINE int ObTimeConverter::get_datetime_digits_delims(
-    const char*& str, const char* end, int32_t max_len, ObTimeDigits& digits, ObTimeDelims& delims)
+    const char *&str, const char *end, int32_t max_len, ObTimeDigits &digits, ObTimeDelims &delims)
 {
   int ret = OB_SUCCESS;
   if (OB_FAIL(get_datetime_digits(str, end, max_len, digits))) {
@@ -5365,7 +5367,7 @@ OB_INLINE int ObTimeConverter::get_datetime_digits_delims(
   return ret;
 }
 
-OB_INLINE void ObTimeConverter::skip_delims(const char*& str, const char* end)
+OB_INLINE void ObTimeConverter::skip_delims(const char *&str, const char *end)
 {
   // str < end best come before any other condition using *str, because end maybe points to memory
   // that can't be access, of course the chance for this situation is very very small.
@@ -5377,53 +5379,53 @@ OB_INLINE bool ObTimeConverter::is_year4(int64_t first_token_len)
   return (4 == first_token_len || 8 == first_token_len || first_token_len >= 14);
 }
 
-OB_INLINE bool ObTimeConverter::is_single_colon(const ObTimeDelims& delims)
+OB_INLINE bool ObTimeConverter::is_single_colon(const ObTimeDelims &delims)
 {
   return (NULL != delims.ptr_ && ':' == *delims.ptr_ && 1 == delims.len_);
 }
 
-OB_INLINE bool ObTimeConverter::is_space_end_with_single_colon(const ObTimeDelims& delims)
+OB_INLINE bool ObTimeConverter::is_space_end_with_single_colon(const ObTimeDelims &delims)
 {
   bool ret = false;
   if (NULL != delims.ptr_ && delims.len_ > 0) {
-    const char* pos = delims.ptr_;
-    const char* end = delims.ptr_ + delims.len_;
+    const char *pos = delims.ptr_;
+    const char *end = delims.ptr_ + delims.len_;
     for (; pos < end && isspace(*pos); ++pos) {}
     ret = (pos + 1 == end && ':' == *pos);
   }
   return ret;
 }
 
-OB_INLINE bool ObTimeConverter::is_single_dot(const ObTimeDelims& delims)
+OB_INLINE bool ObTimeConverter::is_single_dot(const ObTimeDelims &delims)
 {
   return (1 == delims.len_ && NULL != delims.ptr_ && '.' == *delims.ptr_);
 }
 
-OB_INLINE bool ObTimeConverter::is_all_spaces(const ObTimeDelims& delims)
+OB_INLINE bool ObTimeConverter::is_all_spaces(const ObTimeDelims &delims)
 {
   bool ret = false;
   if (NULL != delims.ptr_ && delims.len_ > 0) {
-    const char* pos = delims.ptr_;
-    const char* end = delims.ptr_ + delims.len_;
+    const char *pos = delims.ptr_;
+    const char *end = delims.ptr_ + delims.len_;
     for (; pos < end && isspace(*pos); ++pos) {}
     ret = (pos == end);
   }
   return ret;
 }
 
-OB_INLINE bool ObTimeConverter::has_any_space(const ObTimeDelims& delims)
+OB_INLINE bool ObTimeConverter::has_any_space(const ObTimeDelims &delims)
 {
   bool ret = false;
   if (NULL != delims.ptr_ && delims.len_ > 0) {
-    const char* pos = delims.ptr_;
-    const char* end = delims.ptr_ + delims.len_;
+    const char *pos = delims.ptr_;
+    const char *end = delims.ptr_ + delims.len_;
     for (; pos < end && !isspace(*pos); ++pos) {}
     ret = (pos < end);
   }
   return ret;
 }
 
-OB_INLINE bool ObTimeConverter::is_negative(const char*& str, const char* end)
+OB_INLINE bool ObTimeConverter::is_negative(const char *&str, const char *end)
 {
   // date_add('2015-12-31', interval ' +-@-=  1 - 2' day_hour) => 2016-01-01 02:00:00 .
   // date_add('2015-12-31', interval '  -@-=  1 - 2' day_hour) => 2015-12-29 22:00:00 .
@@ -5439,7 +5441,7 @@ OB_INLINE bool ObTimeConverter::is_negative(const char*& str, const char* end)
 }
 
 OB_INLINE int ObTimeConverter::normalize_usecond_round(
-    ObTimeDigits& digits, const int64_t max_precision, const bool use_strict_check /*false*/)
+    ObTimeDigits &digits, const int64_t max_precision, const bool use_strict_check /*false*/)
 {
   int ret = OB_SUCCESS;
   if (OB_UNLIKELY(digits.value_ < 0) || OB_UNLIKELY(digits.len_ < 0) ||
@@ -5467,7 +5469,7 @@ OB_INLINE int ObTimeConverter::normalize_usecond_round(
   return ret;
 }
 
-OB_INLINE int ObTimeConverter::normalize_usecond_trunc(ObTimeDigits& digits, bool need_trunc)
+OB_INLINE int ObTimeConverter::normalize_usecond_trunc(ObTimeDigits &digits, bool need_trunc)
 {
   int ret = OB_SUCCESS;
   if (digits.value_ < 0 || digits.len_ < 0 || digits.len_ > INT32_MAX_DIGITS_LEN) {
@@ -5485,7 +5487,7 @@ OB_INLINE int ObTimeConverter::normalize_usecond_trunc(ObTimeDigits& digits, boo
   return ret;
 }
 
-OB_INLINE int ObTimeConverter::apply_date_space_rule(const ObTimeDelims* delims)
+OB_INLINE int ObTimeConverter::apply_date_space_rule(const ObTimeDelims *delims)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(delims)) {
@@ -5499,21 +5501,21 @@ OB_INLINE int ObTimeConverter::apply_date_space_rule(const ObTimeDelims* delims)
   return ret;
 }
 
-OB_INLINE void ObTimeConverter::apply_date_year2_rule(ObTimeDigits& year)
+OB_INLINE void ObTimeConverter::apply_date_year2_rule(ObTimeDigits &year)
 {
   if (year.len_ <= 2) {
     year.value_ += (year.value_ < EPOCH_YEAR2 ? 2000 : 1900);
   }
 }
 
-OB_INLINE void ObTimeConverter::apply_date_year2_rule(int32_t& year)
+OB_INLINE void ObTimeConverter::apply_date_year2_rule(int32_t &year)
 {
   if (year < 100) {
     year += (year < EPOCH_YEAR2 ? 2000 : 1900);
   }
 }
 
-OB_INLINE void ObTimeConverter::apply_date_year2_rule(int64_t& year)
+OB_INLINE void ObTimeConverter::apply_date_year2_rule(int64_t &year)
 {
   if (year < 100) {
     year += (year < EPOCH_YEAR2 ? 2000 : 1900);
@@ -5521,7 +5523,7 @@ OB_INLINE void ObTimeConverter::apply_date_year2_rule(int64_t& year)
 }
 
 OB_INLINE int ObTimeConverter::apply_usecond_delim_rule(
-    ObTimeDelims& second, ObTimeDigits& usecond, const int64_t max_precision, const bool use_strict_check)
+    ObTimeDelims &second, ObTimeDigits &usecond, const int64_t max_precision, const bool use_strict_check)
 {
   int ret = OB_SUCCESS;
   if (is_single_dot(second) && usecond.value_ > 0) {
@@ -5533,7 +5535,7 @@ OB_INLINE int ObTimeConverter::apply_usecond_delim_rule(
 }
 
 int ObTimeConverter::apply_datetime_for_time_rule(
-    ObTime& ob_time, const ObTimeDigits* digits, const ObTimeDelims* delims)
+    ObTime &ob_time, const ObTimeDigits *digits, const ObTimeDelims *delims)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(digits) || OB_ISNULL(delims)) {
@@ -5567,7 +5569,7 @@ int ObTimeConverter::apply_datetime_for_time_rule(
 }
 
 // for convert utc time to local time, use get_timezone_offset and no gap/overlap time exist.
-OB_INLINE int ObTimeConverter::add_timezone_offset(const ObTimeZoneInfo* tz_info, int64_t& value)
+OB_INLINE int ObTimeConverter::add_timezone_offset(const ObTimeZoneInfo *tz_info, int64_t &value)
 {
   int ret = OB_SUCCESS;
   if (NULL != tz_info && (ZERO_DATETIME != value || lib::is_oracle_mode())) {
@@ -5582,8 +5584,8 @@ OB_INLINE int ObTimeConverter::add_timezone_offset(const ObTimeZoneInfo* tz_info
 }
 
 // for convert local time to utc time, gap/overlap time may exist.
-OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo* tz_info, bool is_timestamp,
-    const ObString& tz_abbr_str, int64_t& value, const bool is_oracle_mode)
+OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo *tz_info, bool is_timestamp,
+    const ObString &tz_abbr_str, int64_t &value, const bool is_oracle_mode)
 {
   int ret = OB_SUCCESS;
   if (tz_info != NULL && (ZERO_DATETIME != value || is_oracle_mode)) {
@@ -5601,8 +5603,8 @@ OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo* tz_info
   return ret;
 }
 
-OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo& tz_info, const ObString& tz_abbr_str,
-    int64_t& value_us, int32_t& offset_min, int32_t& tz_id, int32_t& tran_type_id)
+OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo &tz_info, const ObString &tz_abbr_str,
+    int64_t &value_us, int32_t &offset_min, int32_t &tz_id, int32_t &tran_type_id)
 {
   int ret = OB_SUCCESS;
   int32_t offset_sec = 0;
@@ -5629,7 +5631,7 @@ OB_INLINE int ObTimeConverter::sub_timezone_offset(const ObTimeZoneInfo& tz_info
   return ret;
 }
 
-int ObTimeConverter::get_str_array_idx(const ObString& str, const ObTimeConstStr* str_arr, int32_t count, int32_t& idx)
+int ObTimeConverter::get_str_array_idx(const ObString &str, const ObTimeConstStr *str_arr, int32_t count, int32_t &idx)
 {
   int ret = OB_SUCCESS;
   if (OB_ISNULL(str.ptr())) {
@@ -5652,7 +5654,7 @@ int ObTimeConverter::get_str_array_idx(const ObString& str, const ObTimeConstStr
   return ret;
 }
 
-void ObTimeConverter::get_first_day_of_isoyear(ObTime& ob_time)
+void ObTimeConverter::get_first_day_of_isoyear(ObTime &ob_time)
 {
   int32_t wday = ob_time.parts_[DT_WDAY];
   int32_t week = ob_time_to_week(ob_time, WEEK_MODE[3]);
@@ -5660,7 +5662,7 @@ void ObTimeConverter::get_first_day_of_isoyear(ObTime& ob_time)
   ob_time.parts_[DT_DATE] -= offset;
 }
 
-int ObTimeConverter::get_round_day_of_isoyear(ObTime& ob_time)
+int ObTimeConverter::get_round_day_of_isoyear(ObTime &ob_time)
 {
   int ret = OB_SUCCESS;
   int32_t wday = ob_time.parts_[DT_WDAY];
@@ -5696,7 +5698,7 @@ bool ObTimeConverter::is_valid_otimestamp(const int64_t time_us, const int32_t t
 }
 
 void ObTimeConverter::calc_oracle_temporal_minus(
-    const ObOTimestampData& v1, const ObOTimestampData& v2, ObIntervalDSValue& result)
+    const ObOTimestampData &v1, const ObOTimestampData &v2, ObIntervalDSValue &result)
 {
   int64_t utc_diff = 0;
   int32_t nsec_diff = 0;
@@ -5716,7 +5718,7 @@ void ObTimeConverter::calc_oracle_temporal_minus(
 }
 
 int ObTimeConverter::date_add_nmonth(
-    const int64_t ori_date_value, const int64_t nmonth, int64_t& result_date_value, bool auto_adjust_mday)
+    const int64_t ori_date_value, const int64_t nmonth, int64_t &result_date_value, bool auto_adjust_mday)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_DATETIME);
@@ -5755,7 +5757,7 @@ int ObTimeConverter::date_add_nmonth(
 }
 
 int ObTimeConverter::date_add_nsecond(
-    const int64_t ori_date_value, const int64_t nsecond, const int32_t fractional_second, int64_t& result_date_value)
+    const int64_t ori_date_value, const int64_t nsecond, const int32_t fractional_second, int64_t &result_date_value)
 {
   int ret = OB_SUCCESS;
   int64_t seconds = nsecond + (fractional_second < 0 ? -1 : 0);
@@ -5769,7 +5771,7 @@ int ObTimeConverter::date_add_nsecond(
 }
 
 int ObTimeConverter::otimestamp_add_nmonth(const ObObjType type, const ObOTimestampData ori_value,
-    const ObTimeZoneInfo* tz_info, const int64_t nmonth, ObOTimestampData& result_value)
+    const ObTimeZoneInfo *tz_info, const int64_t nmonth, ObOTimestampData &result_value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_ORACLE_TIMESTAMP);
@@ -5798,7 +5800,7 @@ int ObTimeConverter::otimestamp_add_nmonth(const ObObjType type, const ObOTimest
 }
 
 int ObTimeConverter::otimestamp_add_nsecond(const ObOTimestampData ori_value, const int64_t nsecond,
-    const int32_t fractional_second, ObOTimestampData& result_value)
+    const int32_t fractional_second, ObOTimestampData &result_value)
 {
   int ret = OB_SUCCESS;
   result_value = ori_value;
@@ -5862,7 +5864,6 @@ int ObTimeConverter::calc_last_date_of_the_month(
         ret = OB_INVALID_ARGUMENT;
         LOG_WARN("unexpected dest type", K(ret), K(dest_type));
       }
-
     }
   }
   LOG_DEBUG("debug calc_last_mday", K(ob_time), K(ori_datetime_value), K(result_date_value));
@@ -5870,7 +5871,7 @@ int ObTimeConverter::calc_last_date_of_the_month(
 }
 
 int ObTimeConverter::calc_next_date_of_the_wday(
-    const int64_t ori_date_value, const ObString& wday_name, int64_t& result_date_value)
+    const int64_t ori_date_value, const ObString &wday_name, int64_t &result_date_value)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time(DT_TYPE_DATETIME);
@@ -5881,7 +5882,7 @@ int ObTimeConverter::calc_next_date_of_the_wday(
     int32_t wday = 0;
     bool found = false;
     for (int32_t i = 1; i <= DAYS_PER_WEEK && !found; ++i) {
-      const ObTimeConstStr& wday_pattern = WDAY_NAMES[i];
+      const ObTimeConstStr &wday_pattern = WDAY_NAMES[i];
       if (0 == wday_name.case_compare(wday_pattern.to_obstring())) {
         found = true;
         wday = i;
@@ -5905,7 +5906,7 @@ int ObTimeConverter::calc_next_date_of_the_wday(
 }
 
 int ObTimeConverter::calc_days_and_months_between_dates(
-    const int64_t date_value1, const int64_t date_value2, int64_t& months_diff, int64_t& rest_utc_diff)
+    const int64_t date_value1, const int64_t date_value2, int64_t &months_diff, int64_t &rest_utc_diff)
 {
   int ret = OB_SUCCESS;
   ObTime ob_time1(DT_TYPE_DATETIME);
@@ -5942,8 +5943,8 @@ int ObTimeConverter::calc_days_and_months_between_dates(
   return ret;
 }
 
-int ObTimeConverter::decode_otimestamp(const ObObjType obj_type, const char* data, const int64_t total_len,
-    const ObTimeConvertCtx& cvrt_ctx, ObOTimestampData& otimestamp_val, int8_t& scale)
+int ObTimeConverter::decode_otimestamp(const ObObjType obj_type, const char *data, const int64_t total_len,
+    const ObTimeConvertCtx &cvrt_ctx, ObOTimestampData &otimestamp_val, int8_t &scale)
 {
   int ret = OB_SUCCESS;
   int8_t year_year = 0;
@@ -5964,7 +5965,7 @@ int ObTimeConverter::decode_otimestamp(const ObObjType obj_type, const char* dat
   ObString tz_abbr;
   const bool is_timestamp_tz = (ObTimestampTZType == obj_type);
 
-  const char* old_data_ptr = data;
+  const char *old_data_ptr = data;
   // read local time
   ObMySQLUtil::get_int1(data, year_year);
   ObMySQLUtil::get_int1(data, year_month);
@@ -6039,15 +6040,15 @@ int ObTimeConverter::decode_otimestamp(const ObObjType obj_type, const char* dat
   return ret;
 }
 
-int ObTimeConverter::encode_otimestamp(const ObObjType obj_type, char* buf, const int64_t len, int64_t& pos,
-    const ObTimeZoneInfo* tz_info, const ObOTimestampData& ot_data, const int8_t& scale)
+int ObTimeConverter::encode_otimestamp(const ObObjType obj_type, char *buf, const int64_t len, int64_t &pos,
+    const ObTimeZoneInfo *tz_info, const ObOTimestampData &ot_data, const int8_t &scale)
 {
   int ret = OB_SUCCESS;
   const bool is_timestamp_tz = (ObTimestampTZType == obj_type);
   const bool store_utc_time = false;
   ObTime ob_time(DT_TYPE_ORACLE_TIMESTAMP);
   int64_t orig_pos = pos;
-  const ObOTimestampData& tmp_ot_data = round_otimestamp(scale, ot_data);
+  const ObOTimestampData &tmp_ot_data = round_otimestamp(scale, ot_data);
   const int8_t tmp_scale = static_cast<int8_t>(scale < 0 ? DEFAULT_SCALE_FOR_ORACLE_FRACTIONAL_SECONDS : scale);
   if (OB_FAIL(otimestamp_to_ob_time(obj_type, tmp_ot_data, tz_info, ob_time, store_utc_time))) {
     LOG_WARN("failed to convert timestamp_tz to ob time", K(ret));
@@ -6120,8 +6121,8 @@ int ObTimeConverter::encode_otimestamp(const ObObjType obj_type, char* buf, cons
   return ret;
 }
 
-int ObTimeConverter::interval_ym_to_str(const ObIntervalYMValue& value, const ObScale scale, char* buf, int64_t buf_len,
-    int64_t& pos, bool fmt_with_interval)
+int ObTimeConverter::interval_ym_to_str(const ObIntervalYMValue &value, const ObScale scale, char *buf, int64_t buf_len,
+    int64_t &pos, bool fmt_with_interval)
 {
   int ret = OB_SUCCESS;
   char format_str[] = "%c%02d-%02d";
@@ -6151,8 +6152,8 @@ int ObTimeConverter::interval_ym_to_str(const ObIntervalYMValue& value, const Ob
   return ret;
 }
 
-int ObTimeConverter::interval_ds_to_str(const ObIntervalDSValue& value, const ObScale scale, char* buf, int64_t buf_len,
-    int64_t& pos, bool fmt_with_interval)
+int ObTimeConverter::interval_ds_to_str(const ObIntervalDSValue &value, const ObScale scale, char *buf, int64_t buf_len,
+    int64_t &pos, bool fmt_with_interval)
 {
   int ret = OB_SUCCESS;
   char format_str_part1[] = "%c%02d %02d:%02d:%02d";
@@ -6205,7 +6206,7 @@ int ObTimeConverter::interval_ds_to_str(const ObIntervalDSValue& value, const Ob
  * @return
  */
 int ObTimeConverter::str_to_interval_ym(
-    const ObString& str, ObIntervalYMValue& value, ObScale& scale, ObDateUnitType part_begin, ObDateUnitType part_end)
+    const ObString &str, ObIntervalYMValue &value, ObScale &scale, ObDateUnitType part_begin, ObDateUnitType part_end)
 {
   int ret = OB_SUCCESS;
   int match_ret = OB_SUCCESS;
@@ -6323,7 +6324,7 @@ int ObTimeConverter::str_to_interval_ym(
  * @return
  */
 int ObTimeConverter::str_to_interval_ds(
-    const ObString& str, ObIntervalDSValue& value, ObScale& scale, ObDateUnitType part_begin, ObDateUnitType part_end)
+    const ObString &str, ObIntervalDSValue &value, ObScale &scale, ObDateUnitType part_begin, ObDateUnitType part_end)
 {
   int ret = OB_SUCCESS;
   int match_ret = OB_SUCCESS;
@@ -6487,7 +6488,7 @@ int ObTimeConverter::str_to_interval_ds(
 }
 
 int ObTimeConverter::encode_interval_ym(
-    char* buf, const int64_t len, int64_t& pos, const ObIntervalYMValue& value, const ObScale scale)
+    char *buf, const int64_t len, int64_t &pos, const ObIntervalYMValue &value, const ObScale scale)
 {
   int ret = OB_SUCCESS;
   int8_t year_scale = ObIntervalScaleUtil::ob_scale_to_interval_ym_year_scale(static_cast<int8_t>(scale));
@@ -6516,7 +6517,7 @@ int ObTimeConverter::encode_interval_ym(
   return ret;
 }
 
-int ObTimeConverter::decode_interval_ym(const char* data, const int64_t len, ObIntervalYMValue& value, ObScale& scale)
+int ObTimeConverter::decode_interval_ym(const char *data, const int64_t len, ObIntervalYMValue &value, ObScale &scale)
 {
   int ret = OB_SUCCESS;
   int8_t is_negative = 0;
@@ -6540,7 +6541,7 @@ int ObTimeConverter::decode_interval_ym(const char* data, const int64_t len, ObI
 }
 
 int ObTimeConverter::encode_interval_ds(
-    char* buf, const int64_t len, int64_t& pos, const ObIntervalDSValue& value, const ObScale scale)
+    char *buf, const int64_t len, int64_t &pos, const ObIntervalDSValue &value, const ObScale scale)
 {
   int ret = OB_SUCCESS;
   int8_t day_scale = ObIntervalScaleUtil::ob_scale_to_interval_ds_day_scale(static_cast<int8_t>(scale));
@@ -6588,7 +6589,7 @@ int ObTimeConverter::encode_interval_ds(
   return ret;
 }
 
-int ObTimeConverter::decode_interval_ds(const char* data, const int64_t len, ObIntervalDSValue& value, ObScale& scale)
+int ObTimeConverter::decode_interval_ds(const char *data, const int64_t len, ObIntervalDSValue &value, ObScale &scale)
 {
   int ret = OB_SUCCESS;
   int8_t is_negative = 0;
@@ -6619,7 +6620,7 @@ int ObTimeConverter::decode_interval_ds(const char* data, const int64_t len, ObI
   return ret;
 }
 
-void ObTimeConverter::interval_ym_to_display_part(const ObIntervalYMValue& value, ObIntervalParts& display_parts)
+void ObTimeConverter::interval_ym_to_display_part(const ObIntervalYMValue &value, ObIntervalParts &display_parts)
 {
   int64_t abs_nmonth = std::abs(value.get_nmonth());
   display_parts.parts_[ObIntervalParts::YEAR_PART] = static_cast<int32_t>(abs_nmonth / MONTHS_PER_YEAR);
@@ -6627,7 +6628,7 @@ void ObTimeConverter::interval_ym_to_display_part(const ObIntervalYMValue& value
   display_parts.is_negative_ = value.is_negative();
 }
 
-void ObTimeConverter::interval_ds_to_display_part(const ObIntervalDSValue& value, ObIntervalParts& display_parts)
+void ObTimeConverter::interval_ds_to_display_part(const ObIntervalDSValue &value, ObIntervalParts &display_parts)
 {
   int64_t abs_nsecond = std::abs(value.get_nsecond());
   int32_t abs_fs = std::abs(value.get_fs());
@@ -6642,7 +6643,7 @@ void ObTimeConverter::interval_ds_to_display_part(const ObIntervalDSValue& value
   display_parts.is_negative_ = value.is_negative();
 }
 
-int ObTimeConverter::iso_str_to_interval_ym(const ObString& str, ObIntervalYMValue& value)
+int ObTimeConverter::iso_str_to_interval_ym(const ObString &str, ObIntervalYMValue &value)
 {
   int ret = OB_SUCCESS;
   ObIntervalParts interval_parts;
@@ -6660,7 +6661,7 @@ int ObTimeConverter::iso_str_to_interval_ym(const ObString& str, ObIntervalYMVal
   return ret;
 }
 
-int ObTimeConverter::iso_str_to_interval_ds(const ObString& str, ObIntervalDSValue& value)
+int ObTimeConverter::iso_str_to_interval_ds(const ObString &str, ObIntervalDSValue &value)
 {
   int ret = OB_SUCCESS;
   ObIntervalParts interval_parts;
@@ -6682,7 +6683,7 @@ int ObTimeConverter::iso_str_to_interval_ds(const ObString& str, ObIntervalDSVal
 }
 
 int ObTimeConverter::iso_interval_str_parse(
-    const ObString& str, ObIntervalParts& interval_parts, ObIntervalParts::PartName begin_part)
+    const ObString &str, ObIntervalParts &interval_parts, ObIntervalParts::PartName begin_part)
 {
   int ret = OB_SUCCESS;
   static const char UNIT[ObIntervalParts::PART_CNT] = {'Y', 'M', 'D', 'H', 'M', '.', 'S'};

src/sql/engine/expr/ob_expr_time_diff.cpp

@@ -24,20 +24,20 @@ namespace oceanbase {
 using namespace common;
 namespace sql {
 
-ObExprTimeDiff::ObExprTimeDiff(ObIAllocator& alloc)
+ObExprTimeDiff::ObExprTimeDiff(ObIAllocator &alloc)
     : ObFuncExprOperator(alloc, T_FUN_SYS_TIME_DIFF, N_TIME_DIFF, 2, NOT_ROW_DIMENSION)
 {}
 
 ObExprTimeDiff::~ObExprTimeDiff()
 {}
 
-int ObExprTimeDiff::calc_result2(ObObj& result, const ObObj& left, const ObObj& right, ObExprCtx& expr_ctx) const
+int ObExprTimeDiff::calc_result2(ObObj &result, const ObObj &left, const ObObj &right, ObExprCtx &expr_ctx) const
 {
   EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
   return calc(result, left, right, cast_ctx);
 }
 
-int ObExprTimeDiff::get_diff_value_with_ob_time(ObTime& ot1, ObTime& ot2, const ObTimeZoneInfo* tz_info, int64_t& diff)
+int ObExprTimeDiff::get_diff_value_with_ob_time(ObTime &ot1, ObTime &ot2, const ObTimeZoneInfo *tz_info, int64_t &diff)
 {
   int ret = OB_SUCCESS;
   int64_t value1 = 0;
@@ -63,7 +63,7 @@ int ObExprTimeDiff::get_diff_value_with_ob_time(ObTime& ot1, ObTime& ot2, const
   return ret;
 }
 
-int ObExprTimeDiff::get_diff_value(const ObObj& obj1, const ObObj& obj2, const ObTimeZoneInfo* tz_info, int64_t& diff)
+int ObExprTimeDiff::get_diff_value(const ObObj &obj1, const ObObj &obj2, const ObTimeZoneInfo *tz_info, int64_t &diff)
 {
   int ret = OB_INVALID_DATE_VALUE;
   ObTime ot1;
@@ -77,7 +77,7 @@ int ObExprTimeDiff::get_diff_value(const ObObj& obj1, const ObObj& obj2, const O
   return ret;
 }
 
-int ObExprTimeDiff::calc(ObObj& result, const ObObj& left, const ObObj& right, ObCastCtx& cast_ctx)
+int ObExprTimeDiff::calc(ObObj &result, const ObObj &left, const ObObj &right, ObCastCtx &cast_ctx)
 {
   int ret = OB_SUCCESS;
   int64_t int64_diff = 0;
@@ -99,7 +99,7 @@ int ObExprTimeDiff::calc(ObObj& result, const ObObj& left, const ObObj& right, O
   return ret;
 }
 
-int ObExprTimeDiff::cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, ObExpr& rt_expr) const
+int ObExprTimeDiff::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr, ObExpr &rt_expr) const
 {
   UNUSED(op_cg_ctx);
   UNUSED(raw_expr);
@@ -116,13 +116,13 @@ int ObExprTimeDiff::cg_expr(ObExprCGCtx& op_cg_ctx, const ObRawExpr& raw_expr, O
   return ret;
 }
 
-int ObExprTimeDiff::calc_timediff(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum)
+int ObExprTimeDiff::calc_timediff(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_datum)
 {
   int ret = OB_SUCCESS;
   bool calc_param_failure = false;
-  ObDatum* param_datum1 = NULL;
-  ObDatum* param_datum2 = NULL;
-  const ObSQLSessionInfo* session = NULL;
+  ObDatum *param_datum1 = NULL;
+  ObDatum *param_datum2 = NULL;
+  const ObSQLSessionInfo *session = NULL;
   if (OB_ISNULL(session = ctx.exec_ctx_.get_my_session())) {
     ret = OB_ERR_UNEXPECTED;
     LOG_WARN("session is null", K(ret));
@@ -133,8 +133,8 @@ int ObExprTimeDiff::calc_timediff(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& e
     expr_datum.set_null();
   } else {
     int64_t int64_diff = 0;
-    ObTime ot1;
-    ObTime ot2;
+    ObTime ot1(DT_TYPE_TIME);
+    ObTime ot2(DT_TYPE_TIME);
     if (OB_FAIL(ob_datum_to_ob_time_without_date(
             *param_datum1, expr.args_[0]->datum_meta_.type_, get_timezone_info(session), ot1))) {
       LOG_WARN("cast the first param failed", K(ret));