diff --git a/be/src/util/string_parser.hpp b/be/src/util/string_parser.hpp
index e95f825dd11b87..2a9a892c96f095 100644
--- a/be/src/util/string_parser.hpp
+++ b/be/src/util/string_parser.hpp
@@ -114,6 +114,7 @@ bool range_suite(const char* s, const char* end) {
 }
 
 inline auto is_digit_range = range_suite<is_numeric_ascii>;
+inline auto is_space_range = range_suite<is_whitespace_ascii>;
 
 inline Status assert_within_bound(const char* s, const char* end, size_t offset) {
     if (s + offset >= end) [[unlikely]] {
diff --git a/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.cpp b/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.cpp
index 71edd0f846ac96..b959d39e6caa11 100644
--- a/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.cpp
@@ -394,7 +394,11 @@ Status DataTypeDateSerDe<T>::from_string_strict_mode_batch(
         CastToDateOrDatetime::from_string_strict_mode<true, IsDatetime>(str, res, options.timezone,
                                                                         params);
         // only after we called something with `IS_STRICT = true`, params.status will be set
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to {} failed: ", str.to_string_view(), name()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<CppType, NativeType>(res);
     }
@@ -433,7 +437,10 @@ Status DataTypeDateSerDe<T>::from_string_strict_mode(StringRef& str, IColumn& co
     CastToDateOrDatetime::from_string_strict_mode<true, IsDatetime>(str, res, options.timezone,
                                                                     params);
     // only after we called something with `IS_STRICT = true`, params.status will be set
-    RETURN_IF_ERROR(params.status);
+    if (!params.status.ok()) [[unlikely]] {
+        params.status.prepend(fmt::format("parse {} to {} failed: ", str.to_string_view(), name()));
+        return params.status;
+    }
     col_data.insert_value(binary_cast<CppType, NativeType>(res));
 
     return Status::OK();
@@ -475,7 +482,11 @@ Status DataTypeDateSerDe<T>::from_int_strict_mode_batch(const IntDataType::Colum
     for (size_t i = 0; i < int_col.size(); ++i) {
         CppType val;
         CastToDateOrDatetime::from_integer<true, IsDatetime>(int_col.get_element(i), val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to {} failed: ", int_col.get_element(i), name()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<CppType, NativeType>(val);
     }
@@ -517,7 +528,11 @@ Status DataTypeDateSerDe<T>::from_float_strict_mode_batch(
     for (size_t i = 0; i < float_col.size(); ++i) {
         CppType val;
         CastToDateOrDatetime::from_float<true, IsDatetime>(float_col.get_data()[i], val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to {} failed: ", float_col.get_data()[i], name()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<CppType, NativeType>(val);
     }
@@ -562,7 +577,12 @@ Status DataTypeDateSerDe<T>::from_decimal_strict_mode_batch(
         CastToDateOrDatetime::from_decimal<true, IsDatetime>(decimal_col.get_intergral_part(i),
                                                              decimal_col.get_fractional_part(i),
                                                              decimal_col.get_scale(), val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {}.{} to {} failed: ", decimal_col.get_intergral_part(i),
+                                decimal_col.get_fractional_part(i), name()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<CppType, NativeType>(val);
     }
diff --git a/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.h b/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.h
index f762b2d8c983b2..0f0e182d4a282b 100644
--- a/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.h
+++ b/be/src/vec/data_types/serde/data_type_date_or_datetime_serde.h
@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <string>
+#include <string_view>
 
 #include "common/status.h"
 #include "data_type_number_serde.h"
@@ -43,6 +44,7 @@ class DataTypeDateSerDe : public DataTypeNumberSerDe<T> {
     using ColumnType = PrimitiveTypeTraits<T>::ColumnType;
     using NativeType = PrimitiveTypeTraits<T>::CppNativeType; // int64
     using CppType = PrimitiveTypeTraits<T>::CppType;          // VecDateTimeValue
+    constexpr static std::string_view name() { return IsDatetime ? "DateTime" : "Date"; }
 
     using typename DataTypeNumberSerDe<T>::FormatOptions;
     DataTypeDateSerDe(int nesting_level = 1) : DataTypeNumberSerDe<T>(nesting_level) {};
diff --git a/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp b/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp
index bcf287346094e2..2bf24368e8b098 100644
--- a/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp
@@ -93,7 +93,11 @@ Status DataTypeDateTimeV2SerDe::from_string_strict_mode_batch(
         DateV2Value<DateTimeV2ValueType> res;
         CastToDatetimeV2::from_string_strict_mode<true>(str, res, options.timezone, _scale, params);
         // only after we called something with `IS_STRICT = true`, params.status will be set
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to datetime failed: ", str.to_string_view()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateTimeV2ValueType>, UInt64>(res);
     }
@@ -128,7 +132,10 @@ Status DataTypeDateTimeV2SerDe::from_string_strict_mode(StringRef& str, IColumn&
     DateV2Value<DateTimeV2ValueType> res;
     CastToDatetimeV2::from_string_strict_mode<true>(str, res, options.timezone, _scale, params);
     // only after we called something with `IS_STRICT = true`, params.status will be set
-    RETURN_IF_ERROR(params.status);
+    if (!params.status.ok()) [[unlikely]] {
+        params.status.prepend(fmt::format("parse {} to datetime failed: ", str.to_string_view()));
+        return params.status;
+    }
     col_data.insert_value(binary_cast<DateV2Value<DateTimeV2ValueType>, UInt64>(res));
     return Status::OK();
 }
@@ -166,7 +173,11 @@ Status DataTypeDateTimeV2SerDe::from_int_strict_mode_batch(const IntDataType::Co
     for (size_t i = 0; i < int_col.size(); ++i) {
         DateV2Value<DateTimeV2ValueType> val;
         CastToDatetimeV2::from_integer<true>(int_col.get_element(i), val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to datetime failed: ", int_col.get_element(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateTimeV2ValueType>, UInt64>(val);
     }
@@ -207,7 +218,11 @@ Status DataTypeDateTimeV2SerDe::from_float_strict_mode_batch(
     for (size_t i = 0; i < float_col.size(); ++i) {
         DateV2Value<DateTimeV2ValueType> val;
         CastToDatetimeV2::from_float<true>(float_col.get_data()[i], val, _scale, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to datetime failed: ", float_col.get_data()[i]));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateTimeV2ValueType>, UInt64>(val);
     }
@@ -251,7 +266,12 @@ Status DataTypeDateTimeV2SerDe::from_decimal_strict_mode_batch(
         CastToDatetimeV2::from_decimal<true>(decimal_col.get_intergral_part(i),
                                              decimal_col.get_fractional_part(i),
                                              decimal_col.get_scale(), val, _scale, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(fmt::format(
+                    "parse {}.{} to datetime failed: ", decimal_col.get_intergral_part(i),
+                    decimal_col.get_fractional_part(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateTimeV2ValueType>, UInt64>(val);
     }
diff --git a/be/src/vec/data_types/serde/data_type_datev2_serde.cpp b/be/src/vec/data_types/serde/data_type_datev2_serde.cpp
index fb26768d5df35a..360aa7cd59f6cc 100644
--- a/be/src/vec/data_types/serde/data_type_datev2_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_datev2_serde.cpp
@@ -19,6 +19,7 @@
 
 #include <arrow/builder.h>
 #include <cctz/time_zone.h>
+#include <fmt/core.h>
 
 #include <cstdint>
 
@@ -270,7 +271,10 @@ Status DataTypeDateV2SerDe::from_string_strict_mode_batch(
         DateV2Value<DateV2ValueType> res;
         CastToDateV2::from_string_strict_mode<true>(str, res, options.timezone, params);
         // only after we called something with `IS_STRICT = true`, params.status will be set
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(fmt::format("parse {} to date failed: ", str.to_string_view()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateV2ValueType>, UInt32>(res);
     }
@@ -305,7 +309,10 @@ Status DataTypeDateV2SerDe::from_string_strict_mode(StringRef& str, IColumn& col
     DateV2Value<DateV2ValueType> res;
     CastToDateV2::from_string_strict_mode<true>(str, res, options.timezone, params);
     // only after we called something with `IS_STRICT = true`, params.status will be set
-    RETURN_IF_ERROR(params.status);
+    if (!params.status.ok()) [[unlikely]] {
+        params.status.prepend(fmt::format("parse {} to date failed: ", str.to_string_view()));
+        return params.status;
+    }
 
     col_data.insert_value(binary_cast<DateV2Value<DateV2ValueType>, UInt32>(res));
     return Status::OK();
@@ -343,7 +350,10 @@ Status DataTypeDateV2SerDe::from_int_strict_mode_batch(const IntDataType::Column
     for (size_t i = 0; i < int_col.size(); ++i) {
         DateV2Value<DateV2ValueType> val;
         CastToDateV2::from_integer<true>(int_col.get_element(i), val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(fmt::format("parse {} to date failed: ", int_col.get_element(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateV2ValueType>, UInt32>(val);
     }
@@ -382,7 +392,11 @@ Status DataTypeDateV2SerDe::from_float_strict_mode_batch(const FloatDataType::Co
     for (size_t i = 0; i < float_col.size(); ++i) {
         DateV2Value<DateV2ValueType> val;
         CastToDateV2::from_float<true>(float_col.get_data()[i], val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to date failed: ", float_col.get_data()[i]));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateV2ValueType>, UInt32>(val);
     }
@@ -423,7 +437,12 @@ Status DataTypeDateV2SerDe::from_decimal_strict_mode_batch(
         DateV2Value<DateV2ValueType> val;
         CastToDateV2::from_decimal<true>(decimal_col.get_intergral_part(i), decimal_col.get_scale(),
                                          val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {}.{} to date failed: ", decimal_col.get_intergral_part(i),
+                                decimal_col.get_fractional_part(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = binary_cast<DateV2Value<DateV2ValueType>, UInt32>(val);
     }
diff --git a/be/src/vec/data_types/serde/data_type_time_serde.cpp b/be/src/vec/data_types/serde/data_type_time_serde.cpp
index c641dcf14a2694..a31701aa41836c 100644
--- a/be/src/vec/data_types/serde/data_type_time_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_time_serde.cpp
@@ -109,7 +109,10 @@ Status DataTypeTimeV2SerDe::from_string_strict_mode_batch(
         TimeValue::TimeType res;
         CastToTimeV2::from_string_strict_mode<true>(str, res, options.timezone, _scale, params);
         // only after we called something with `IS_STRICT = true`, params.status will be set
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(fmt::format("parse {} to time failed: ", str.to_string_view()));
+            return params.status;
+        }
 
         col_data.get_data()[i] = res;
     }
@@ -141,7 +144,11 @@ Status DataTypeTimeV2SerDe::from_string_strict_mode(StringRef& str, IColumn& col
     TimeValue::TimeType res;
     CastToTimeV2::from_string_strict_mode<true>(str, res, options.timezone, _scale, params);
     // only after we called something with `IS_STRICT = true`, params.status will be set
-    RETURN_IF_ERROR(params.status);
+    if (!params.status.ok()) [[unlikely]] {
+        params.status.prepend(fmt::format("parse {} to time failed: ", str.to_string_view()));
+        return params.status;
+    }
+
     col_data.insert_value(res);
     return Status::OK();
 }
@@ -178,7 +185,10 @@ Status DataTypeTimeV2SerDe::from_int_strict_mode_batch(const IntDataType::Column
     for (size_t i = 0; i < int_col.size(); ++i) {
         TimeValue::TimeType val = 0;
         CastToTimeV2::from_integer<true>(int_col.get_element(i), val, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(fmt::format("parse {} to time failed: ", int_col.get_element(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = val;
     }
@@ -218,7 +228,11 @@ Status DataTypeTimeV2SerDe::from_float_strict_mode_batch(const FloatDataType::Co
     for (size_t i = 0; i < float_col.size(); ++i) {
         TimeValue::TimeType val = 0;
         CastToTimeV2::from_float<true>(float_col.get_data()[i], val, _scale, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {} to time failed: ", float_col.get_data()[i]));
+            return params.status;
+        }
 
         col_data.get_data()[i] = val;
     }
@@ -261,7 +275,12 @@ Status DataTypeTimeV2SerDe::from_decimal_strict_mode_batch(
         CastToTimeV2::from_decimal<true>(decimal_col.get_intergral_part(i),
                                          decimal_col.get_fractional_part(i),
                                          decimal_col.get_scale(), val, _scale, params);
-        RETURN_IF_ERROR(params.status);
+        if (!params.status.ok()) [[unlikely]] {
+            params.status.prepend(
+                    fmt::format("parse {}.{} to time failed: ", decimal_col.get_intergral_part(i),
+                                decimal_col.get_fractional_part(i)));
+            return params.status;
+        }
 
         col_data.get_data()[i] = val;
     }
diff --git a/be/src/vec/functions/cast/cast_to_datetimev2_impl.hpp b/be/src/vec/functions/cast/cast_to_datetimev2_impl.hpp
index f79e729fb9e26e..ba41b76d1e92c5 100644
--- a/be/src/vec/functions/cast/cast_to_datetimev2_impl.hpp
+++ b/be/src/vec/functions/cast/cast_to_datetimev2_impl.hpp
@@ -442,7 +442,10 @@ inline bool CastToDatetimeV2::from_string_strict_mode(const StringRef& str,
     SET_PARAMS_RET_FALSE_IF_ERR((consume_digit<UInt32, 1, 2>(ptr, end, part[0])));
     SET_PARAMS_RET_FALSE_IFN(res.set_time_unit<TimeUnit::HOUR>(part[0]), "invalid hour {}",
                              part[0]);
-    SET_PARAMS_RET_FALSE_IF_ERR(assert_within_bound(ptr, end, 0));
+    if (ptr == end) {
+        // no minute part, just return.
+        return true;
+    }
     if (*ptr == ':') {
         // with hour:minute:second
         if (consume_one_colon(ptr, end)) { // minute
@@ -675,7 +678,7 @@ inline bool CastToDatetimeV2::from_string_non_strict_mode_impl(
         SET_PARAMS_RET_FALSE_IFN(res.set_time_unit<TimeUnit::DAY>(day), "invalid day {}", day);
     }
 
-    if (ptr == end) {
+    if (is_space_range(ptr, end)) {
         // no time part, just return.
         res.unchecked_set_time_unit<TimeUnit::HOUR>(0);
         res.unchecked_set_time_unit<TimeUnit::MINUTE>(0);
diff --git a/be/src/vec/functions/cast/cast_to_datev2_impl.hpp b/be/src/vec/functions/cast/cast_to_datev2_impl.hpp
index 79910b5a042728..e4bfbc3e85d968 100644
--- a/be/src/vec/functions/cast/cast_to_datev2_impl.hpp
+++ b/be/src/vec/functions/cast/cast_to_datev2_impl.hpp
@@ -24,6 +24,7 @@
 #include "cast_base.h"
 #include "common/status.h"
 #include "runtime/primitive_type.h"
+#include "util/string_parser.hpp"
 #include "vec/core/types.h"
 #include "vec/data_types/data_type_decimal.h" // IWYU pragma: keep
 #include "vec/data_types/serde/data_type_serde.h"
@@ -377,7 +378,10 @@ inline bool CastToDateV2::from_string_strict_mode(const StringRef& str,
     SET_PARAMS_RET_FALSE_IF_ERR((consume_digit<UInt32, 1, 2>(ptr, end, part[0])));
     SET_PARAMS_RET_FALSE_IFN(res.test_time_unit<TimeUnit::HOUR>(part[0]), "invalid hour {}",
                              part[0]);
-    SET_PARAMS_RET_FALSE_IF_ERR(assert_within_bound(ptr, end, 0));
+    if (ptr == end) {
+        // no minute part, just return.
+        return true;
+    }
     if (*ptr == ':') {
         // with hour:minute:second
         if (consume_one_colon(ptr, end)) { // minute
@@ -559,7 +563,7 @@ inline bool CastToDateV2::from_string_non_strict_mode_impl(const StringRef& str,
         SET_PARAMS_RET_FALSE_IFN(res.set_time_unit<TimeUnit::DAY>(day), "invalid day {}", day);
     }
 
-    if (ptr == end) {
+    if (is_space_range(ptr, end)) {
         // no time part, just return.
         return true;
     }
diff --git a/be/src/vec/functions/cast/cast_to_time_impl.hpp b/be/src/vec/functions/cast/cast_to_time_impl.hpp
index 076d110556f5dd..db7110336caea5 100644
--- a/be/src/vec/functions/cast/cast_to_time_impl.hpp
+++ b/be/src/vec/functions/cast/cast_to_time_impl.hpp
@@ -221,56 +221,18 @@ inline bool CastToTimeV2::from_integer(T input, TimeValue::TimeType& val, CastPa
 }
 
 /**
-<datetime>       ::= <date> (("T" | " ") <time> <whitespace>* <offset>?)?
+<time> ::= ("+" | "-")? (<colon-format> | <numeric-format>)
 
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-
-<date>           ::= <year> "-" <month1> "-" <day1>
-                   | <year> <month2> <day2>
-
-<year>           ::= <digit>{2} | <digit>{4} ; 1970 为界
-<month1>         ::= <digit>{1,2}            ; 01–12
-<day1>           ::= <digit>{1,2}            ; 01–28/29/30/31 视月份而定
-
-<month2>         ::= <digit>{2}              ; 01–12
-<day2>           ::= <digit>{2}              ; 01–28/29/30/31 视月份而定
-
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-
-<time>           ::= <hour1> (":" <minute1> (":" <second1> <fraction>?)?)?
-                   | <hour2> (<minute2> (<second2> <fraction>?)?)?
-
-<hour1>           ::= <digit>{1,2}      ; 00–23
-<minute1>         ::= <digit>{1,2}      ; 00–59
-<second1>         ::= <digit>{1,2}      ; 00–59
-
-<hour2>           ::= <digit>{2}        ; 00–23
-<minute2>         ::= <digit>{2}        ; 00–59
-<second2>         ::= <digit>{2}        ; 00–59
-
-<fraction>        ::= "." <digit>*
-
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-
-<offset>         ::= ( "+" | "-" ) <hour-offset> [ ":"? <minute-offset> ]
-                   | <tz-name>
-
-<tz-name>        ::= <short-tz> | <long-tz> 
-
-<short-tz>       ::= "CST" | "UTC" | "GMT" | "ZULU" | "Z"   ; 忽略大小写
-<long-tz>        ::= <area> "/" <location>                  ; e.g. America/New_York
-
-<hour-offset>    ::= <digit>{1,2}      ; 0–14
-<minute-offset>  ::= <digit>{2}        ; 00/30/45
+<colon-format> ::= <hour> ":" <minute> (":" <second> (<microsecond>)?)?
+<hour> ::= <digit>+
+<minute> ::= <digit>{1,2}
+<second> ::= <digit>{1,2}
 
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
+<numeric-format> ::= <digit>+ (<microsecond>)?
 
-<digit>          ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+<microsecond> ::= "." <digit>*
 
-<area>           ::= <alpha>+
-<location>       ::= (<alpha> | "_")+
-<alpha>          ::= "A" | … | "Z" | "a" | … | "z"
-<whitespace>     ::= " " | "\t" | "\n" | "\r" | "\v" | "\f"
+<digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
 */
 template <bool IsStrict>
 inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValue::TimeType& res,
@@ -459,46 +421,19 @@ inline bool CastToTimeV2::from_string_strict_mode(const StringRef& str, TimeValu
 }
 
 /**
-<datetime> ::= <whitespace>* <date> (<delimiter> <time> <whitespace>* <timezone>?)? <whitespace>*
+<time> ::= <whitespace>* ("+" | "-")? (<colon-format> | <numeric-format>) <whitespace>*
 
-<date> ::= <year> <separator> <month> <separator> <day>
-<time> ::= <hour> <separator> <minute> <separator> <second> [<fraction>]
-
-<year> ::= <digit>{4} | <digit>{2}
-<month> ::= <digit>{1,2}
-<day> ::= <digit>{1,2}
-<hour> ::= <digit>{1,2}
+<colon-format> ::= <hour> ":" <minute> (":" <second> (<microsecond>)?)?
+<hour> ::= <digit>+
 <minute> ::= <digit>{1,2}
 <second> ::= <digit>{1,2}
 
-<separator> ::= ^(<digit> | <alpha>)
-<delimiter> ::= " " | "T"
-
-<fraction> ::= "." <digit>*
-
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-
-<offset>         ::= ( "+" | "-" ) <hour-offset> [ ":"? <minute-offset> ]
-                   | <tz-name>
-
-<tz-name>        ::= <short-tz> | <long-tz> 
+<numeric-format> ::= <digit>+ (<microsecond>)?
 
-<short-tz>       ::= "CST" | "UTC" | "GMT" | "ZULU" | "Z"   ; 忽略大小写
-<long-tz>        ::= <area> "/" <location>                  ; e.g. America/New_York
-
-<hour-offset>    ::= <digit>{1,2}      ; 0–14
-<minute-offset>  ::= <digit>{2}        ; 00/30/45
-
-<area>           ::= <alpha>+
-<location>       ::= (<alpha> | "_")+
-
-––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––
-
-<whitespace> ::= " " | "\t" | "\n" | "\r" | "\v" | "\f"
+<microsecond> ::= "." <digit>*
 
 <digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
-
-<alpha>          ::= "A" | … | "Z" | "a" | … | "z"
+<whitespace> ::= " " | "\t" | "\n" | "\r" | "\v" | "\f"
 */
 inline bool CastToTimeV2::from_string_non_strict_mode_impl(const StringRef& str,
                                                            TimeValue::TimeType& res,
diff --git a/be/test/vec/function/cast/cast_test.h b/be/test/vec/function/cast/cast_test.h
index 70ce1c9eb55643..9390a945f754be 100644
--- a/be/test/vec/function/cast/cast_test.h
+++ b/be/test/vec/function/cast/cast_test.h
@@ -229,8 +229,6 @@ struct FunctionCastTest : public testing::Test {
                     << ", result: " << to_type->to_string(*result, i)
                     << ", expected: " << to_type->to_string(*expected, i);
         }
-
-        std::cout << "block \n" << block.dump_data() << "\n";
     }
 
     // we always need return nullable=true for cast function because of its' get_return_type weird
@@ -240,29 +238,22 @@ struct FunctionCastTest : public testing::Test {
                                  bool expect_execute_fail = false, bool expect_result_ne = false) {
         std::string func_name = "CAST";
 
-        InputTypeSet add_input_types = input_types;
         if constexpr (IsDataTypeDecimal<ResultDataType>) {
             ResultDataType result_data_type(result_precision, result_scale);
-            add_input_types.emplace_back(ConstedNotnull {result_data_type.get_primitive_type()});
+            input_types.emplace_back(ConstedNotnull {result_data_type.get_primitive_type()});
         } else {
-            add_input_types.emplace_back(ConstedNotnull {ResultDataType {}.get_primitive_type()});
+            input_types.emplace_back(ConstedNotnull {ResultDataType {}.get_primitive_type()});
         }
-        // add_input_types.push_back(ConstedNotnull {TypeId<typename ResultDataType::FieldType>::value});
-
-        // the column-1(target type placeholder) must be const. so we must split the data_set into const_datasets with
-        // only 1 row.
-        for (const auto& row : data_set) {
-            auto add_row = row;
-            add_row.first.push_back(ut_type::ut_input_type_default_v<ResultDataType>);
-            DataSet const_dataset = {add_row};
 
+        if (!data_set.empty()) {
+            data_set[0].first.push_back(ut_type::ut_input_type_default_v<ResultDataType>);
             if (datetime_is_string_format) {
                 static_cast<void>(check_function<ResultDataType, true, true>(
-                        func_name, add_input_types, const_dataset, result_scale, result_precision,
+                        func_name, input_types, data_set, result_scale, result_precision,
                         expect_execute_fail, expect_result_ne, enable_strict_cast));
             } else {
                 static_cast<void>(check_function<ResultDataType, true, false>(
-                        func_name, add_input_types, const_dataset, result_scale, result_precision,
+                        func_name, input_types, data_set, result_scale, result_precision,
                         expect_execute_fail, expect_result_ne, enable_strict_cast));
             }
         }
@@ -272,57 +263,39 @@ struct FunctionCastTest : public testing::Test {
     template <typename ResultDataType>
     void check_function_for_cast_strict_mode(InputTypeSet input_types, DataSet data_set,
                                              std::string expect_error = "", int result_scale = -1,
-                                             int result_precision = -1,
-                                             bool datetime_is_string_format = true) {
-        constexpr bool expect_result_ne = false;
-
+                                             int result_precision = -1) {
         const bool expect_execute_fail = !expect_error.empty();
         std::string func_name = "CAST";
 
-        InputTypeSet add_input_types = input_types;
         if constexpr (IsDataTypeDecimal<ResultDataType>) {
             ResultDataType result_data_type(result_precision, result_scale);
-            add_input_types.emplace_back(ConstedNotnull {result_data_type.get_primitive_type()});
+            input_types.emplace_back(ConstedNotnull {result_data_type.get_primitive_type()});
         } else {
-            add_input_types.emplace_back(ConstedNotnull {ResultDataType {}.get_primitive_type()});
+            input_types.emplace_back(ConstedNotnull {ResultDataType {}.get_primitive_type()});
         }
-        // add_input_types.push_back(ConstedNotnull {TypeId<typename ResultDataType::FieldType>::value});
-
-        // the column-1(target type placeholder) must be const. so we must split the data_set into const_datasets with
-        // only 1 row.
-        for (const auto& row : data_set) {
-            auto add_row = row;
-            add_row.first.push_back(ut_type::ut_input_type_default_v<ResultDataType>);
-            DataSet const_dataset = {add_row};
 
-            if (datetime_is_string_format) {
-                if (expect_execute_fail) {
-                    Status st = check_function<ResultDataType, true, true>(
-                            func_name, add_input_types, const_dataset, result_scale,
-                            result_precision, expect_execute_fail, expect_result_ne, true);
-                    EXPECT_TRUE(st.msg().find(expect_error) != std::string::npos)
-                            << ""
-                            << "expect error: " << expect_error << ", but got: " << st.msg();
-
-                } else {
-                    static_cast<void>(check_function<ResultDataType, true, true>(
-                            func_name, add_input_types, const_dataset, result_scale,
-                            result_precision, expect_execute_fail, expect_result_ne, true));
-                }
-            } else {
-                if (expect_execute_fail) {
-                    Status st = check_function<ResultDataType, true, false>(
-                            func_name, add_input_types, const_dataset, result_scale,
-                            result_precision, expect_execute_fail, expect_result_ne, true);
-                    EXPECT_TRUE(st.msg().find(expect_error) != std::string::npos)
-                            << ""
-                            << "expect error: " << expect_error << ", but got: " << st.msg();
-
-                } else {
-                    static_cast<void>(check_function<ResultDataType, true, false>(
-                            func_name, add_input_types, const_dataset, result_scale,
-                            result_precision, expect_execute_fail, expect_result_ne, true));
-                }
+        if (expect_execute_fail) {
+            TestCaseInfo::error_line_number = -1;
+            for (const auto& row : data_set) {
+                TestCaseInfo::error_line_number++;
+                auto add_row = row;
+                add_row.first.push_back(ut_type::ut_input_type_default_v<ResultDataType>);
+                DataSet one_row_dataset = {add_row};
+
+                Status st = check_function<ResultDataType, true, true>(
+                        func_name, input_types, one_row_dataset, result_scale, result_precision,
+                        true, false, true);
+                EXPECT_TRUE(st.msg().find(expect_error) != std::string::npos)
+                        << "\nexpect error: " << expect_error << ", but got: " << st.msg();
+            }
+        } else {
+            // row.first is input, in cast we have two columns and the second is a placeholder of target type.
+            // we need some data in it. it's a const column. so only need one row.
+            if (!data_set.empty()) {
+                data_set[0].first.push_back(ut_type::ut_input_type_default_v<ResultDataType>);
+                static_cast<void>(check_function<ResultDataType, true, true>(
+                        func_name, input_types, data_set, result_scale, result_precision, false,
+                        false, true));
             }
         }
     }
diff --git a/be/test/vec/function/cast/cast_to_date_test.cpp b/be/test/vec/function/cast/cast_to_date_test.cpp
index 47e8d6e470e5e1..5475f6b6b04650 100644
--- a/be/test/vec/function/cast/cast_to_date_test.cpp
+++ b/be/test/vec/function/cast/cast_to_date_test.cpp
@@ -21,7 +21,7 @@
 namespace doris::vectorized {
 using namespace ut_type;
 
-TEST_F(FunctionCastTest, strict_test_from_string_to_date) {
+TEST_F(FunctionCastTest, string_to_date_valid_case_strict_mode) {
     InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
     DataSet data_set = {
             // Valid ISO 8601 format with timezone
@@ -30,7 +30,6 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_date) {
             {{std::string("2023-07-16T1920+08:00")}, std::string("2023-07-16")},
             {{std::string("2023-07-16T1920+00:00")}, std::string("2023-07-16")},
             {{std::string("70-1-1T00:00:00-0000")}, std::string("1970-01-01")},
-            {{std::string("19991231T235960.5UTC")}, Null()},
 
             // Date with timezone names
             {{std::string("2024-02-29 12:00:00 Europe/Paris")}, std::string("2024-02-29")},
@@ -45,12 +44,130 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_date) {
             {{std::string("2024-05-01 0:1:2.")}, std::string("2024-05-01")},
 
             // Compact formats
-            {{std::string("20240501 01")}, Null()},
+            {{std::string("20240501 01")}, std::string("2024-05-01")},
+            {{std::string("20230716 1920Z")}, std::string("2023-07-16")},
+            {{std::string("20240501T0000")}, std::string("2024-05-01")},
+
+            // High precision timestamps
+            {{std::string("2024-12-31 23:59:59.9999999999999999999")}, std::string("2024-12-31")},
+
+            // Various timezone offsets
+            {{std::string("2020-12-12 13:12:12-03:00")}, std::string("2020-12-12")},
+            {{std::string("0023-01-01T00:00Z")}, std::string("0023-01-01")},
+
+            // Year cutoff cases
+            {{std::string("69-12-31")}, std::string("2069-12-31")},
+            {{std::string("70-01-01")}, std::string("1970-01-01")},
+
+            // Compact numeric formats
+            {{std::string("230102")}, std::string("2023-01-02")},
+            {{std::string("19230101")}, std::string("1923-01-01")},
+            {{std::string("20120102030405")}, std::string("2012-01-02")},
+
+            {{std::string("2024-02-29T23:59:59.999999 UTC")}, std::string("2024-02-29")},
+            {{std::string("70-01-01T00:00:00+14")}, std::string("1970-01-01")},
+            {{std::string("0023-1-1T1:2:3. -00:00")}, std::string("0023-01-01")},
+            {{std::string("20-1-1")}, std::string("2020-01-01")},
+            {{std::string("0123-12-12")}, std::string("0123-12-12")},
+            {{std::string("01231212")}, std::string("0123-12-12")},
+            {{std::string("68-01-01")}, std::string("2068-01-01")},
+            {{std::string("69-01-01")}, std::string("2069-01-01")},
+            {{std::string("71-01-01")}, std::string("1971-01-01")},
+            {{std::string("99-12-31")}, std::string("1999-12-31")},
+            {{std::string("00-01-01")}, std::string("2000-01-01")},
+            {{std::string("12010203040506.999")}, std::string("1201-02-03")},
+            {{std::string("12010203040506.")}, std::string("1201-02-03")},
+    };
+    check_function_for_cast_strict_mode<DataTypeDateV2>(input_types, data_set);
+}
+
+TEST_F(FunctionCastTest, string_to_date_invalid_cases_in_strict_mode) {
+    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    DataSet data_set = {
+            // Invalid formats. in strict
+            {{std::string("abc")}, Null()},
+            {{std::string("2020-05-05 12:30:60")}, Null()},
+            {{std::string("2023-07-16T19.123+08:00")}, Null()},
+            {{std::string("2024/05/01")}, Null()},
+            {{std::string("24012")}, Null()},
+            {{std::string("2411 123")}, Null()},
+            {{std::string("2024-05-01 01:030:02")}, Null()},
+            {{std::string("10000-01-01 00:00:00")}, Null()},
+            {{std::string("2024-0131T12:00")}, Null()},
+            {{std::string("2024-05-01@00:00")}, Null()},
+            {{std::string("20120212051")}, Null()},
+            {{std::string("2024-05-01T00:00XYZ")}, Null()},
+            {{std::string("2024-5-1T24:00")}, Null()},
+            {{std::string("2024-02-30")}, Null()},
+            {{std::string("2024-05-01T12:60")}, Null()},
+            {{std::string("2012-06-30T23:59:60")}, Null()},
+            {{std::string("2024-05-01T00:00+14:30")}, Null()},
+            {{std::string("2024-05-01T00:00+08:25")}, Null()},
+            {{std::string("2020-12-12   12:12:12")}, Null()},
+            {{std::string("2020-12-12T 12:12:12")}, Null()},
+            {{std::string("2020-12-12 +12:12:12")}, Null()},
+            {{std::string("2020-12-12 -12:12:12")}, Null()},
+            {{std::string("2011")}, Null()},
+            {{std::string("123-12-12")}, Null()},
+            {{std::string("1-12-12")}, Null()},
+            {{std::string("00123-12-12")}, Null()},
+            {{std::string("1231212")}, Null()},
+            {{std::string("0000-02-29")}, Null()}, // should fix
+            {{std::string("")}, Null()},
+            {{std::string("   ")}, Null()},
+            {{std::string("2024−05−01")}, Null()},
+            {{std::string("２０２４－０５－０１")}, Null()},
+            {{std::string("2024/05/01#12:00")}, Null()},
+            {{std::string("2024-05-01&12:00:00")}, Null()},
+            {{std::string("2024-5-1-12:00")}, Null()},
+            {{std::string("05/01/2024T12")}, Null()},
+            {{std::string("2024年05月01日")}, Null()},
+            {{std::string("2024-05-01\t12:00:00")}, Null()},
+            {{std::string(" 2024-05-01 ")}, Null()},
+            {{std::string("  2024-05-01T12:00:00  ")}, Null()},
+            {{std::string("2024 - 05 - 01")}, Null()},
+            {{std::string("2024-05-01  12:00:00")}, Null()},
+            {{std::string("2024.05.01")}, Null()},
+            {{std::string("2024.05.01 12.30.45")}, Null()},
+            {{std::string("2024/05-01T12:30:45")}, Null()},
+            {{std::string("2024-05/01 12.30.45")}, Null()},
+            {{std::string("2025/06/15T00:00:00.99999999999999")}, Null()},
+            {{std::string("-1")}, Null()},
+            {{std::string("-12")}, Null()},
+            {{std::string("-1234")}, Null()},
+    };
+    check_function_for_cast_strict_mode<DataTypeDateV2>(input_types, data_set, "date");
+}
+
+TEST_F(FunctionCastTest, string_to_date_strict_case_non_strict_mode) {
+    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    DataSet data_set = {
+            // Valid ISO 8601 format with timezone
+            {{std::string("2023-07-16T19:20:30.123+08:00")}, std::string("2023-07-16")},
+            {{std::string("2023-07-16T19+08:00")}, std::string("2023-07-16")},
+            {{std::string("2023-07-16T1920+08:00")}, std::string("2023-07-16")},
+            {{std::string("2023-07-16T1920+00:00")}, std::string("2023-07-16")},
+            {{std::string("70-1-1T00:00:00-0000")}, std::string("1970-01-01")},
+
+            // Date with timezone names
+            {{std::string("2024-02-29 12:00:00 Europe/Paris")}, std::string("2024-02-29")},
+            {{std::string("2024-05-01T00:00Asia/Shanghai")}, std::string("2024-05-01")},
+            {{std::string("20231005T081530Europe/London")}, std::string("2023-10-05")},
+            {{std::string("85-12-25T0000gMt")}, std::string("1985-12-25")},
+
+            // Simple date formats
+            {{std::string("2024-05-01")}, std::string("2024-05-01")},
+            {{std::string("24-5-1")}, std::string("2024-05-01")},
+            {{std::string("2024-05-01 0:1:2.333")}, std::string("2024-05-01")},
+            {{std::string("2024-05-01 0:1:2.")}, std::string("2024-05-01")},
+
+            // Compact formats
+            {{std::string("20240501 01")}, std::string("2024-05-01")},
             {{std::string("20230716 1920Z")}, std::string("2023-07-16")},
             {{std::string("20240501T0000")}, std::string("2024-05-01")},
 
             // High precision timestamps
-            {{std::string("2024-12-31 23:59:59.9999999")}, std::string("2024-12-31")},
+            {{std::string("2024-12-31 23:59:59.9999999999999999999")}, std::string("2024-12-31")},
             {{std::string("2025/06/15T00:00:00.99999999999999")}, std::string("2025-06-15")},
 
             // Various timezone offsets
@@ -67,11 +184,12 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_date) {
             {{std::string("120102030405")}, Null()},
             {{std::string("20120102030405")}, std::string("2012-01-02")},
             {{std::string("120102030405.999")}, Null()},
+            {{std::string("2024/05/01")}, std::string("2024-05-01")},
 
             // Invalid formats (should return NULL)
+            {{std::string("19991231T235960.5UTC")}, Null()},
             {{std::string("2020-05-05 12:30:60")}, Null()},
             {{std::string("2023-07-16T19.123+08:00")}, Null()},
-            {{std::string("2024/05/01")}, std::string("2024-05-01")},
             {{std::string("24012")}, Null()},
             {{std::string("2411 123")}, Null()},
             {{std::string("2024-05-01 01:030:02")}, Null()},
@@ -85,35 +203,32 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_date) {
             {{std::string("2024-05-01T12:60")}, Null()},
             {{std::string("2012-06-30T23:59:60")}, Null()},
             {{std::string("2024-05-01T00:00+14:30")}, Null()},
-            {{std::string("2024-05-01T00:00+08:25")}, Null()}};
+            {{std::string("2024-05-01T00:00+08:25")}, Null()},
+            {{std::string("2024-02-29T23-59-60ZULU")}, Null()},
+            {{std::string("2024 12 31T121212.123456 America/New_York")}, Null()},
+            {{std::string("123.123")}, Null()},
+            {{std::string("12121")}, Null()},
+            {{std::string("2024/05/01#12:00")}, Null()},
+            {{std::string("2024-05-01&12:00:00")}, Null()},
+            {{std::string("2024-5-1-12:00")}, Null()},
+            {{std::string("05/01/2024T12")}, Null()},
+            {{std::string("2024年05月01日")}, Null()},
+            {{std::string("2024-05-01\t12:00:00")}, Null()},
+            {{std::string("-1")}, Null()},
+            {{std::string("-12")}, Null()},
+            {{std::string("-1234")}, Null()},
+            {{std::string("2024~05~01~12~00~00")}, Null()},
+            {{std::string("2024#05#01#12#00#00")}, Null()},
+            {{std::string("2024- 05- 01")}, Null()},
+            {{std::string("2024 -05 -01")}, Null()},
+            {{std::string("2024-05 -01T12: 00: 00")}, Null()},
+            {{std::string("2024--05--01")}, Null()},
+            {{std::string("2024//05//01")}, Null()},
+    };
     check_function_for_cast<DataTypeDateV2>(input_types, data_set);
 }
 
-TEST_F(FunctionCastTest, invalid_cases_in_strict_mode) {
-    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
-    DataSet data_set = {// Invalid formats. in strict
-                        {{std::string("abc")}, Null()},
-                        {{std::string("2020-05-05 12:30:60")}, Null()},
-                        {{std::string("2023-07-16T19.123+08:00")}, Null()},
-                        {{std::string("2024/05/01")}, std::string("2024-05-01")},
-                        {{std::string("24012")}, Null()},
-                        {{std::string("2411 123")}, Null()},
-                        {{std::string("2024-05-01 01:030:02")}, Null()},
-                        {{std::string("10000-01-01 00:00:00")}, Null()},
-                        {{std::string("2024-0131T12:00")}, Null()},
-                        {{std::string("2024-05-01@00:00")}, Null()},
-                        {{std::string("20120212051")}, Null()},
-                        {{std::string("2024-05-01T00:00XYZ")}, Null()},
-                        {{std::string("2024-5-1T24:00")}, Null()},
-                        {{std::string("2024-02-30")}, Null()},
-                        {{std::string("2024-05-01T12:60")}, Null()},
-                        {{std::string("2012-06-30T23:59:60")}, Null()},
-                        {{std::string("2024-05-01T00:00+14:30")}, Null()},
-                        {{std::string("2024-05-01T00:00+08:25")}, Null()}};
-    check_function_for_cast_strict_mode<DataTypeDateV2>(input_types, data_set, " ");
-}
-
-TEST_F(FunctionCastTest, non_strict_test_from_string_to_date) {
+TEST_F(FunctionCastTest, string_to_date_non_strict_case_non_strict_mode) {
     InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
     DataSet data_set = {
             // Flexible date formats
@@ -121,22 +236,25 @@ TEST_F(FunctionCastTest, non_strict_test_from_string_to_date) {
             {{std::string("99.12.31 23.59.59+05:30")}, std::string("1999-12-31")},
             {{std::string("2000/01/01T00/00/00-230")}, std::string("2000-01-01")},
             {{std::string("85 1 1T0 0 0. CST")}, std::string("1985-01-01")},
-            {{std::string("2024-02-29T23:59:59.999999 UTC")}, std::string("2024-02-29")},
-            {{std::string("70-01-01T00:00:00+14")}, std::string("1970-01-01")},
-            {{std::string("0023-1-1T1:2:3. -00:00")}, std::string("0023-01-01")},
             {{std::string("2025/06/15T00:00:00.0-0")}, std::string("2025-06-15")},
             {{std::string("2025/06/15T00:00:00.99999999999")}, std::string("2025-06-15")},
-            {{std::string("2024-02-29T23-59-60ZULU")}, Null()},
-            {{std::string("2024 12 31T121212.123456 America/New_York")}, Null()},
 
-            // Invalid formats
-            {{std::string("123.123")}, Null()},
-            {{std::string("12121")}, Null()},
+            {{std::string("  2024-05-01T12:00:00  ")}, std::string("2024-05-01")},
+            {{std::string("2024.05.01")}, std::string("2024-05-01")},
+            {{std::string("2024.05.01 12.30.45")}, std::string("2024-05-01")},
+            {{std::string("2024/05-01T12:30:45")}, std::string("2024-05-01")},
+            {{std::string("2024-05/01 12.30.45")}, std::string("2024-05-01")},
+
+            {{std::string(" 2024-05-01 ")}, std::string("2024-05-01")},
+            {{std::string("2024|05|01")}, std::string("2024-05-01")},
+            {{std::string("2024^05^01")}, std::string("2024-05-01")},
+            {{std::string("2024~05~01 12~00~00")}, std::string("2024-05-01")},
+            {{std::string("2024#05#01T12#00#00")}, std::string("2024-05-01")},
     };
     check_function_for_cast<DataTypeDateV2>(input_types, data_set);
 }
 
-TEST_F(FunctionCastTest, test_string_to_date_error_cases) {
+TEST_F(FunctionCastTest, test_string_to_date_error_cases_1) {
     {
         InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
         DataSet data_set = {
diff --git a/be/test/vec/function/cast/cast_to_datetime_test.cpp b/be/test/vec/function/cast/cast_to_datetime_test.cpp
index f4d45875d6fb53..8c657fb2b8ad82 100644
--- a/be/test/vec/function/cast/cast_to_datetime_test.cpp
+++ b/be/test/vec/function/cast/cast_to_datetime_test.cpp
@@ -21,7 +21,7 @@
 namespace doris::vectorized {
 using namespace ut_type;
 
-TEST_F(FunctionCastTest, strict_test_from_string_to_datetime) {
+TEST_F(FunctionCastTest, string_to_datetime6_valid_case_strict_mode) {
     InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
     DataSet data_set = {
             // Valid ISO 8601 format with timezone
@@ -30,7 +30,6 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_datetime) {
             {{std::string("2023-07-16T19+08:00")}, std::string("2023-07-16 19:00:00.000000")},
             {{std::string("2023-07-16T1920+08:00")}, std::string("2023-07-16 19:20:00.000000")},
             {{std::string("70-1-1T00:00:00-0000")}, std::string("1970-01-01 08:00:00.000000")},
-            {{std::string("19991231T235960.5UTC")}, Null()},
 
             // Date with timezone names
             {{std::string("2024-02-29 12:00:00 Europe/Paris")},
@@ -47,19 +46,18 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_datetime) {
             {{std::string("2024-05-01 0:1:2.")}, std::string("2024-05-01 00:01:02")},
 
             // Compact formats
-            {{std::string("20240501 01")}, Null()},
+            {{std::string("20240501 01")}, std::string("2024-05-01 01:00:00")},
             {{std::string("20230716 1920Z")}, std::string("2023-07-17 03:20:00")},
             {{std::string("20240501T0000")}, std::string("2024-05-01")},
 
             // High precision timestamps
-            {{std::string("2024-12-31 23:59:59.9999999")}, std::string("2025-01-01")},
-            {{std::string("2025/06/15T00:00:00.99999999999999")},
-             std::string("2025-06-15 00:00:01")},
+            {{std::string("2024-12-31 23:59:59.9999999999999999999")}, std::string("2025-01-01")},
 
             // Various timezone offsets
             {{std::string("2020-12-12 13:12:12-03:00")}, std::string("2020-12-13 00:12:12")},
-            // CST of shanghai before 1900 is not +080000 but +080543
-            {{std::string("0023-01-01T00:00Z")}, std::string("0023-01-01 08:05:43")},
+            {{std::string("0023-01-01T00:00Z")},
+             std::string(
+                     "0023-01-01 08:05:43")}, // CST of shanghai before 1900 is not +080000 but +080543
 
             // Year cutoff cases
             {{std::string("69-12-31")}, std::string("2069-12-31")},
@@ -68,14 +66,151 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_datetime) {
             // Compact numeric formats
             {{std::string("230102")}, std::string("2023-01-02")},
             {{std::string("19230101")}, std::string("1923-01-01")},
-            {{std::string("120102030405")}, Null()},
             {{std::string("20120102030405")}, std::string("2012-01-02 03:04:05")},
-            {{std::string("120102030405.999")}, Null()},
 
-            // Invalid formats (should return NULL)
+            {{std::string("2024-02-29T23:59:59.999999 UTC")},
+             std::string("2024-03-01 07:59:59.999999")},
+            {{std::string("70-01-01T00:00:00+14")}, std::string("1969-12-31 18:00:00")},
+            {{std::string("0023-1-1T1:2:3. -00:00")}, std::string("0023-01-01 09:07:46")},
+            {{std::string("20-1-1")}, std::string("2020-01-01")},
+            {{std::string("0123-12-12")}, std::string("0123-12-12")},
+            {{std::string("01231212")}, std::string("0123-12-12")},
+            {{std::string("68-01-01")}, std::string("2068-01-01")},
+            {{std::string("69-01-01")}, std::string("2069-01-01")},
+            {{std::string("71-01-01")}, std::string("1971-01-01")},
+            {{std::string("99-12-31")}, std::string("1999-12-31")},
+            {{std::string("00-01-01")}, std::string("2000-01-01")},
+            {{std::string("12010203040506.999")}, std::string("1201-02-03 04:05:06.999000")},
+            {{std::string("12010203040506.")}, std::string("1201-02-03 04:05:06")},
+    };
+    check_function_for_cast_strict_mode<DataTypeDateTimeV2>(input_types, data_set, "", 6);
+}
+
+TEST_F(FunctionCastTest, string_to_datetime6_invalid_cases_in_strict_mode) {
+    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    DataSet data_set = {
+            // Invalid formats. in strict
+            {{std::string("abc")}, Null()},
             {{std::string("2020-05-05 12:30:60")}, Null()},
             {{std::string("2023-07-16T19.123+08:00")}, Null()},
+            {{std::string("2024/05/01")}, Null()},
+            {{std::string("24012")}, Null()},
+            {{std::string("2411 123")}, Null()},
+            {{std::string("2024-05-01 01:030:02")}, Null()},
+            {{std::string("10000-01-01 00:00:00")}, Null()},
+            {{std::string("2024-0131T12:00")}, Null()},
+            {{std::string("2024-05-01@00:00")}, Null()},
+            {{std::string("20120212051")}, Null()},
+            {{std::string("2024-05-01T00:00XYZ")}, Null()},
+            {{std::string("2024-5-1T24:00")}, Null()},
+            {{std::string("2024-02-30")}, Null()},
+            {{std::string("2024-05-01T12:60")}, Null()},
+            {{std::string("2012-06-30T23:59:60")}, Null()},
+            {{std::string("2024-05-01T00:00+14:30")}, Null()},
+            {{std::string("2024-05-01T00:00+08:25")}, Null()},
+            {{std::string("2020-12-12   12:12:12")}, Null()},
+            {{std::string("2020-12-12T 12:12:12")}, Null()},
+            {{std::string("2020-12-12 +12:12:12")}, Null()},
+            {{std::string("2020-12-12 -12:12:12")}, Null()},
+            {{std::string("2011")}, Null()},
+            {{std::string("123-12-12")}, Null()},
+            {{std::string("1-12-12")}, Null()},
+            {{std::string("00123-12-12")}, Null()},
+            {{std::string("1231212")}, Null()},
+            {{std::string("0000-02-29")}, Null()}, // should fix
+            {{std::string("")}, Null()},
+            {{std::string("   ")}, Null()},
+            {{std::string("2024−05−01")}, Null()},
+            {{std::string("２０２４－０５－０１")}, Null()},
+            {{std::string("2024/05/01#12:00")}, Null()},
+            {{std::string("2024-05-01&12:00:00")}, Null()},
+            {{std::string("2024-5-1-12:00")}, Null()},
+            {{std::string("05/01/2024T12")}, Null()},
+            {{std::string("2024年05月01日")}, Null()},
+            {{std::string("2024-05-01\t12:00:00")}, Null()},
+            {{std::string(" 2024-05-01 ")}, Null()},
+            {{std::string("  2024-05-01T12:00:00  ")}, Null()},
+            {{std::string("2024 - 05 - 01")}, Null()},
+            {{std::string("2024-05-01  12:00:00")}, Null()},
+            {{std::string("2024.05.01")}, Null()},
+            {{std::string("2024.05.01 12.30.45")}, Null()},
+            {{std::string("2024/05-01T12:30:45")}, Null()},
+            {{std::string("2024-05/01 12.30.45")}, Null()},
+            {{std::string("2025/06/15T00:00:00.99999999999999")}, Null()},
+            {{std::string("-1")}, Null()},
+            {{std::string("-12")}, Null()},
+            {{std::string("-1234")}, Null()},
+    };
+    check_function_for_cast_strict_mode<DataTypeDateTimeV2>(input_types, data_set, "datetime", 6);
+}
+
+TEST_F(FunctionCastTest, string_to_datetime6_strict_case_non_strict_mode) {
+    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    DataSet data_set = {
+            // Valid ISO 8601 format with timezone
+            {{std::string("2023-07-16T19:20:30.123+08:00")},
+             std::string("2023-07-16 19:20:30.123000")},
+            {{std::string("2023-07-16T19+08:00")}, std::string("2023-07-16 19:00:00.000000")},
+            {{std::string("2023-07-16T1920+08:00")}, std::string("2023-07-16 19:20:00.000000")},
+            {{std::string("70-1-1T00:00:00-0000")}, std::string("1970-01-01 08:00:00.000000")},
+
+            // Date with timezone names
+            {{std::string("2024-02-29 12:00:00 Europe/Paris")},
+             std::string("2024-02-29 19:00:00.000000")},
+            {{std::string("2024-05-01T00:00Asia/Shanghai")},
+             std::string("2024-05-01 00:00:00.000000")},
+            {{std::string("20231005T081530Europe/London")}, std::string("2023-10-05 15:15:30")},
+            {{std::string("85-12-25T0000gMt")}, std::string("1985-12-25 08:00:00")},
+
+            // Simple date formats
+            {{std::string("2024-05-01")}, std::string("2024-05-01")},
+            {{std::string("24-5-1")}, std::string("2024-05-01")},
+            {{std::string("2024-05-01 0:1:2.333")}, std::string("2024-05-01 00:01:02.333000")},
+            {{std::string("2024-05-01 0:1:2.")}, std::string("2024-05-01 00:01:02")},
+
+            // Compact formats
+            {{std::string("20240501 01")}, std::string("2024-05-01 01:00:00")},
+            {{std::string("20230716 1920Z")}, std::string("2023-07-17 03:20:00")},
+            {{std::string("20240501T0000")}, std::string("2024-05-01")},
+
+            // High precision timestamps
+            {{std::string("2024-12-31 23:59:59.9999999999999999999")}, std::string("2025-01-01")},
+
+            // Various timezone offsets
+            {{std::string("2020-12-12 13:12:12-03:00")}, std::string("2020-12-13 00:12:12")},
+            {{std::string("0023-01-01T00:00Z")},
+             std::string(
+                     "0023-01-01 08:05:43")}, // CST of shanghai before 1900 is not +080000 but +080543
+
+            // Year cutoff cases
+            {{std::string("69-12-31")}, std::string("2069-12-31")},
+            {{std::string("70-01-01")}, std::string("1970-01-01")},
+
+            // Compact numeric formats
+            {{std::string("230102")}, std::string("2023-01-02")},
+            {{std::string("19230101")}, std::string("1923-01-01")},
+            {{std::string("20120102030405")}, std::string("2012-01-02 03:04:05")},
+
+            {{std::string("2024-02-29T23:59:59.999999 UTC")},
+             std::string("2024-03-01 07:59:59.999999")},
+            {{std::string("70-01-01T00:00:00+14")}, std::string("1969-12-31 18:00:00")},
+            {{std::string("0023-1-1T1:2:3. -00:00")}, std::string("0023-01-01 09:07:46")},
+            {{std::string("20-1-1")}, std::string("2020-01-01")},
+            {{std::string("0123-12-12")}, std::string("0123-12-12")},
+            {{std::string("01231212")}, std::string("0123-12-12")},
+            {{std::string("68-01-01")}, std::string("2068-01-01")},
+            {{std::string("69-01-01")}, std::string("2069-01-01")},
+            {{std::string("71-01-01")}, std::string("1971-01-01")},
+            {{std::string("99-12-31")}, std::string("1999-12-31")},
+            {{std::string("00-01-01")}, std::string("2000-01-01")},
+            {{std::string("12010203040506.999")}, std::string("1201-02-03 04:05:06.999000")},
+            {{std::string("12010203040506.")}, std::string("1201-02-03 04:05:06")},
             {{std::string("2024/05/01")}, std::string("2024-05-01")},
+
+            // Invalid formats (should return NULL)
+            {{std::string("19991231T235960.5UTC")}, Null()},
+            {{std::string("2020-05-05 12:30:60")}, Null()},
+            {{std::string("2023-07-16T19.123+08:00")}, Null()},
             {{std::string("24012")}, Null()},
             {{std::string("2411 123")}, Null()},
             {{std::string("2024-05-01 01:030:02")}, Null()},
@@ -83,14 +218,34 @@ TEST_F(FunctionCastTest, strict_test_from_string_to_datetime) {
             {{std::string("2024-0131T12:00")}, Null()},
             {{std::string("2024-05-01@00:00")}, Null()},
             {{std::string("20120212051")}, Null()},
-            {{std::string("20120212T051213")}, std::string("2012-02-12 05:12:13")},
             {{std::string("2024-05-01T00:00XYZ")}, Null()},
             {{std::string("2024-5-1T24:00")}, Null()},
             {{std::string("2024-02-30")}, Null()},
             {{std::string("2024-05-01T12:60")}, Null()},
             {{std::string("2012-06-30T23:59:60")}, Null()},
             {{std::string("2024-05-01T00:00+14:30")}, Null()},
-            {{std::string("2024-05-01T00:00+08:25")}, Null()}};
+            {{std::string("2024-05-01T00:00+08:25")}, Null()},
+            {{std::string("2024-02-29T23-59-60ZULU")}, Null()},
+            {{std::string("2024 12 31T121212.123456 America/New_York")}, Null()},
+            {{std::string("123.123")}, Null()},
+            {{std::string("12121")}, Null()},
+            {{std::string("2024/05/01#12:00")}, Null()},
+            {{std::string("2024-05-01&12:00:00")}, Null()},
+            {{std::string("2024-5-1-12:00")}, Null()},
+            {{std::string("05/01/2024T12")}, Null()},
+            {{std::string("2024年05月01日")}, Null()},
+            {{std::string("2024-05-01\t12:00:00")}, Null()},
+            {{std::string("-1")}, Null()},
+            {{std::string("-12")}, Null()},
+            {{std::string("-1234")}, Null()},
+            {{std::string("2024~05~01~12~00~00")}, Null()},
+            {{std::string("2024#05#01#12#00#00")}, Null()},
+            {{std::string("2024- 05- 01")}, Null()},
+            {{std::string("2024 -05 -01")}, Null()},
+            {{std::string("2024-05 -01T12: 00: 00")}, Null()},
+            {{std::string("2024--05--01")}, Null()},
+            {{std::string("2024//05//01")}, Null()},
+    };
     check_function_for_cast<DataTypeDateTimeV2>(input_types, data_set, 6);
 }
 
@@ -109,12 +264,19 @@ TEST_F(FunctionCastTest, non_strict_test_from_string_to_datetime) {
             {{std::string("2025/06/15T00:00:00")}, std::string("2025-06-15 00:00:00.000000")},
             {{std::string("2025/06/15T00:00:00.99999999999")},
              std::string("2025-06-15 00:00:01.000000")},
-            {{std::string("2024-02-29T23-59-60ZULU")}, Null()},
-            {{std::string("2024 12 31T121212.123456 America/New_York")}, Null()},
 
-            // Invalid formats
-            {{std::string("123.123")}, Null()},
-            {{std::string("12121")}, Null()},
+            {{std::string("2025/06/15T00:00:00.0-0")}, std::string("2025-06-15 08:00:00")},
+            {{std::string("2025/06/15T00:00:00.99999999999")}, std::string("2025-06-15 00:00:01")},
+            {{std::string("  2024-05-01T12:00:00  ")}, std::string("2024-05-01 12:00:00")},
+            {{std::string("2024.05.01")}, std::string("2024-05-01")},
+            {{std::string("2024.05.01 12.30.45")}, std::string("2024-05-01 12:30:45")},
+            {{std::string("2024/05-01T12:30:45")}, std::string("2024-05-01 12:30:45")},
+            {{std::string("2024-05/01 12.30.45")}, std::string("2024-05-01 12:30:45")},
+            {{std::string(" 2024-05-01 ")}, std::string("2024-05-01")},
+            {{std::string("2024|05|01")}, std::string("2024-05-01")},
+            {{std::string("2024^05^01")}, std::string("2024-05-01")},
+            {{std::string("2024~05~01 12~00~00")}, std::string("2024-05-01 12:00:00")},
+            {{std::string("2024#05#01T12#00#00")}, std::string("2024-05-01 12:00:00")},
     };
     check_function_for_cast<DataTypeDateTimeV2>(input_types, data_set, 6);
 }
@@ -207,5 +369,6 @@ TEST_F(FunctionCastTest, test_from_time_to_datetime) {
         check_function_for_cast<DataTypeDateTimeV2>(input_types, data_set, 6);
     }
 }
+//FIXME: fix cast with different scale then add cases about datetime to datetime
 
 } // namespace doris::vectorized
diff --git a/be/test/vec/function/cast/cast_to_time_test.cpp b/be/test/vec/function/cast/cast_to_time_test.cpp
index db8cad1cc7d96b..4197f6455969e9 100644
--- a/be/test/vec/function/cast/cast_to_time_test.cpp
+++ b/be/test/vec/function/cast/cast_to_time_test.cpp
@@ -19,32 +19,71 @@
 
 namespace doris::vectorized {
 
-TEST_F(FunctionCastTest, test_from_string_to_time) {
+TEST_F(FunctionCastTest, test_from_string_strict_mode_to_time) {
     InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
-    // now it's wrong. here input can't parse microseconds.
-    DataSet data_set = {{{std::string("1")}, std::string("00:00:01.000000")},
-                        {{std::string("123")}, std::string("00:01:23.000000")},
-                        {{std::string("2005959.12")}, std::string("200:59:59.120000")},
-                        {{std::string("0.12")}, std::string("00:00:00.120000")},
-                        {{std::string("00:00:00.12")}, std::string("00:00:00.120000")},
-                        {{std::string("123.")}, std::string("00:01:23.000000")},
-                        {{std::string("123.0")}, std::string("00:01:23.000000")},
-                        {{std::string("123.123")}, std::string("00:01:23.123000")},
-                        {{std::string("-1")}, std::string("-00:00:01.000000")},
-                        {{std::string("-800:05:05")}, std::string("-800:05:05.000000")},
-                        {{std::string("-991213.56")}, std::string("-99:12:13.560000")},
-                        {{std::string("80302.9999999")}, std::string("08:03:03.000000")},
-                        {{std::string("5656.3000000009")}, std::string("00:56:56.300000")},
-                        {{std::string("5656.3000007001")}, std::string("00:56:56.300001")},
-                        {{std::string("   1   ")}, std::string("00:00:01.000000")},
-                        {{std::string(".123")}, Null()},
-                        {{std::string(":12:34")}, Null()},
-                        {{std::string("12-34:56.1")}, Null()},
-                        {{std::string("12 : 34 : 56")}, Null()},
-                        {{std::string("76")}, Null()},
-                        {{std::string("200595912")}, Null()},
-                        {{std::string("8385959.9999999")}, Null()},
-                        {{Null()}, Null()}};
+    // success cases
+    {
+        DataSet data_set = {
+                {{std::string("1")}, std::string("00:00:01.000000")},
+                {{std::string("123")}, std::string("00:01:23.000000")},
+                {{std::string("2005959.12")}, std::string("200:59:59.120000")},
+                {{std::string("0.12")}, std::string("00:00:00.120000")},
+                {{std::string("00:00:00.12")}, std::string("00:00:00.120000")},
+                {{std::string("123.")}, std::string("00:01:23.000000")},
+                {{std::string("123.0")}, std::string("00:01:23.000000")},
+                {{std::string("123.123")}, std::string("00:01:23.123000")},
+                {{std::string("-1")}, std::string("-00:00:01.000000")},
+                {{std::string("-800:05:05")}, std::string("-800:05:05.000000")},
+                {{std::string("-991213.56")}, std::string("-99:12:13.560000")},
+                {{std::string("80302.9999999")}, std::string("08:03:03.000000")},
+                {{std::string("5656.3000000009")}, std::string("00:56:56.300000")},
+                {{std::string("5656.3000007001")}, std::string("00:56:56.300001")},
+        };
+        check_function_for_cast_strict_mode<DataTypeTimeV2>(input_types, data_set, "", 6);
+    }
+    // failed cases
+    {
+        DataSet data_set = {
+                {{std::string(".123")}, Null()},
+                {{std::string(":12:34")}, Null()},
+                {{std::string("12-34:56.1")}, Null()},
+                {{std::string("12 : 34 : 56")}, Null()},
+                {{std::string("76")}, Null()},
+                {{std::string("200595912")}, Null()},
+                {{std::string("8385959.9999999")}, Null()},
+                {{std::string("   1   ")}, Null()},
+        };
+        check_function_for_cast_strict_mode<DataTypeTimeV2>(input_types, data_set, "time", 6);
+    }
+}
+
+TEST_F(FunctionCastTest, test_from_string_non_strict_mode_to_time) {
+    InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+    DataSet data_set = {
+            {{std::string("1")}, std::string("00:00:01.000000")},
+            {{std::string("123")}, std::string("00:01:23.000000")},
+            {{std::string("2005959.12")}, std::string("200:59:59.120000")},
+            {{std::string("0.12")}, std::string("00:00:00.120000")},
+            {{std::string("00:00:00.12")}, std::string("00:00:00.120000")},
+            {{std::string("123.")}, std::string("00:01:23.000000")},
+            {{std::string("123.0")}, std::string("00:01:23.000000")},
+            {{std::string("123.123")}, std::string("00:01:23.123000")},
+            {{std::string("-1")}, std::string("-00:00:01.000000")},
+            {{std::string("-800:05:05")}, std::string("-800:05:05.000000")},
+            {{std::string("-991213.56")}, std::string("-99:12:13.560000")},
+            {{std::string("80302.9999999")}, std::string("08:03:03.000000")},
+            {{std::string("5656.3000000009")}, std::string("00:56:56.300000")},
+            {{std::string("5656.3000007001")}, std::string("00:56:56.300001")},
+            {{std::string("   1   ")}, std::string("00:00:01.000000")},
+            {{std::string(".123")}, Null()},
+            {{std::string(":12:34")}, Null()},
+            {{std::string("12-34:56.1")}, Null()},
+            {{std::string("12 : 34 : 56")}, Null()},
+            {{std::string("76")}, Null()},
+            {{std::string("200595912")}, Null()},
+            {{std::string("8385959.9999999")}, Null()},
+            {{Null()}, Null()},
+    };
     check_function_for_cast<DataTypeTimeV2>(input_types, data_set, 6);
 }
 
@@ -92,7 +131,7 @@ TEST_F(FunctionCastTest, test_from_numeric_to_time) {
                                      {{DECIMAL64(20001212, 0, 5)}, Null()},
                                      {{DECIMAL64(67, 0, 5)}, Null()},
                                      {{Null()}, Null()}};
-        check_function_for_cast<DataTypeTimeV2>(input_types_d32_p0s0, data_set_d32_p0s0, 3, true);
+        check_function_for_cast<DataTypeTimeV2>(input_types_d32_p0s0, data_set_d32_p0s0, 3);
     }
 }
 
@@ -101,7 +140,8 @@ TEST_F(FunctionCastTest, test_from_datetime_to_time) {
     InputTypeSet input_types = {{PrimitiveType::TYPE_DATETIMEV2, 6}};
     DataSet data_set = {
             {{std::string("2012-02-05 12:12:12.123456")}, std::string("12:12:12.1235")}};
-    check_function_for_cast<DataTypeTimeV2>(input_types, data_set, 4, true);
+    check_function_for_cast<DataTypeTimeV2>(input_types, data_set, 4);
 }
+//FIXME: fix cast with different scale then add cases about time to time
 
 } // namespace doris::vectorized
diff --git a/be/test/vec/function/function_test_util.h b/be/test/vec/function/function_test_util.h
index 71362adf21bd2c..a58fd0a91e6064 100644
--- a/be/test/vec/function/function_test_util.h
+++ b/be/test/vec/function/function_test_util.h
@@ -318,7 +318,9 @@ Status check_function(const std::string& func_name, const InputTypeSet& input_ty
         auto column = desc.data_type->create_column();
         column->reserve(row_size);
 
-        for (int j = 0; j < row_size; j++) {
+        // for function cast, the second column is const but there's many rows in block. so we only insert one row
+        // for the second column.
+        for (int j = 0; j < ((func_name == "CAST" && i == 1) ? 1 : row_size); j++) {
             // null dealed in insert_cell
             EXPECT_TRUE(insert_cell(column, desc.data_type, data_set[j].first[i],
                                     datetime_is_string_format));
@@ -390,6 +392,10 @@ Status check_function(const std::string& func_name, const InputTypeSet& input_ty
         return st;
     } else {
         EXPECT_EQ(Status::OK(), st);
+        // avoid subsequent visit
+        if (st != Status::OK()) {
+            return st;
+        }
     }
 
     static_cast<void>(func->close(fn_ctx, FunctionContext::THREAD_LOCAL));
diff --git a/regression-test/data/cast_p0/cast_to_datetime.out b/regression-test/data/cast_p0/cast_to_datetime.out
index c469a0de0782ed..2fd8ddc241991c 100644
--- a/regression-test/data/cast_p0/cast_to_datetime.out
+++ b/regression-test/data/cast_p0/cast_to_datetime.out
@@ -39,7 +39,7 @@
 2024-05-01T00:01:02
 
 -- !sql14 --
-\N
+2024-05-01T01:00
 
 -- !sql15 --
 2023-07-17T03:20
@@ -225,7 +225,7 @@
 2024-05-01T00:01:02
 
 -- !sql76 --
-\N
+2024-05-01T01:00
 
 -- !sql77 --
 2023-07-17T03:20
@@ -405,7 +405,7 @@
 2024-05-01T00:01:02
 
 -- !sql136 --
-\N
+2024-05-01T01:00
 
 -- !sql137 --
 2023-07-17T03:20