diff --git a/be/CMakeLists.txt b/be/CMakeLists.txt
index cc0b6bbdc1..0ca8ae7b4f 100644
--- a/be/CMakeLists.txt
+++ b/be/CMakeLists.txt
@@ -76,6 +76,10 @@ else()
 endif()
 option(USE_JEMALLOC "Use jemalloc" ON)
 
+if (DISPLAY_BUILD_TIME)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "time -f 'TimeUsage: real=%es, user=%Us, sys=%Ss'")
+endif()
+
 message(STATUS "GLIBC_COMPATIBILITY is ${GLIBC_COMPATIBILITY}")
 message(STATUS "USE_LIBCPP is ${USE_LIBCPP}")
 message(STATUS "USE_MEM_TRACKER is ${USE_MEM_TRACKER}")
@@ -132,7 +136,7 @@ set(Boost_DEBUG FALSE)
 set(Boost_USE_MULTITHREADED ON)
 set(Boost_ROOT ${THIRDPARTY_DIR})
 set(Boost_NO_BOOST_CMAKE OFF)
-set(BOOST_VERSION "1.73.0")
+set(BOOST_VERSION "1.81.0")
 
 if (NOT APPLE)
     find_package(Boost ${BOOST_VERSION} REQUIRED COMPONENTS system date_time)
@@ -935,7 +939,7 @@ endif ()
 
 get_directory_property(COMPILER_FLAGS COMPILE_OPTIONS)
 get_directory_property(COMPILER_DEFINES COMPILE_DEFINITIONS)
-message(STATUS "Compiler: ${CMAKE_CXX_COMPILER_ID}")
+message(STATUS "Compiler: ${CMAKE_CXX_COMPILER_ID}-${CMAKE_CXX_COMPILER_VERSION}")
 message(STATUS "CXX Standard: ${CMAKE_CXX_STANDARD}")
 message(STATUS "C Standard: ${CMAKE_C_STANDARD}")
 message(STATUS "CXX Flags: ${CMAKE_CXX_FLAGS}")
diff --git a/be/src/vec/CMakeLists.txt b/be/src/vec/CMakeLists.txt
index 49cfd007e1..ce61f91af9 100644
--- a/be/src/vec/CMakeLists.txt
+++ b/be/src/vec/CMakeLists.txt
@@ -30,7 +30,8 @@ set(VEC_FILES
   aggregate_functions/aggregate_function_sum.cpp
   aggregate_functions/aggregate_function_sort.cpp
   aggregate_functions/aggregate_function_min_max.cpp
-  aggregate_functions/aggregate_function_min_max_by.cpp
+  aggregate_functions/aggregate_function_min_by.cpp
+  aggregate_functions/aggregate_function_max_by.cpp
   aggregate_functions/aggregate_function_uniq.cpp
   aggregate_functions/aggregate_function_hll_union_agg.cpp
   aggregate_functions/aggregate_function_bit.cpp
diff --git a/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp
new file mode 100644
index 0000000000..b2c44689bc
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_max_by.cpp
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
+#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
+
+namespace doris::vectorized {
+
+void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both(
+            "max_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
+                                                           AggregateFunctionMaxByData>);
+}
+
+} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp
new file mode 100644
index 0000000000..a860bea088
--- /dev/null
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_by.cpp
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
+#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
+
+namespace doris::vectorized {
+
+void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory) {
+    factory.register_function_both(
+            "min_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
+                                                           AggregateFunctionMinByData>);
+}
+
+} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max.h b/be/src/vec/aggregate_functions/aggregate_function_min_max.h
index f4692bc818..1afd8e75f6 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max.h
@@ -447,12 +447,10 @@ struct AggregateFunctionMaxData : public Data {
     using Self = AggregateFunctionMaxData;
     using Data::IsFixedLength;
 
-    bool change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
-        return this->change_if_greater(column, row_num, arena);
-    }
-    bool change_if_better(const Self& to, Arena* arena) {
-        return this->change_if_greater(to, arena);
+    void change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
+        this->change_if_greater(column, row_num, arena);
     }
+    void change_if_better(const Self& to, Arena* arena) { this->change_if_greater(to, arena); }
 
     static const char* name() { return "max"; }
 };
@@ -462,10 +460,10 @@ struct AggregateFunctionMinData : Data {
     using Self = AggregateFunctionMinData;
     using Data::IsFixedLength;
 
-    bool change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
-        return this->change_if_less(column, row_num, arena);
+    void change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
+        this->change_if_less(column, row_num, arena);
     }
-    bool change_if_better(const Self& to, Arena* arena) { return this->change_if_less(to, arena); }
+    void change_if_better(const Self& to, Arena* arena) { this->change_if_less(to, arena); }
 
     static const char* name() { return "min"; }
 };
@@ -475,12 +473,10 @@ struct AggregateFunctionAnyData : Data {
     using Self = AggregateFunctionAnyData;
     using Data::IsFixedLength;
 
-    bool change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
-        return this->change_first_time(column, row_num, arena);
-    }
-    bool change_if_better(const Self& to, Arena* arena) {
-        return this->change_first_time(to, arena);
+    void change_if_better(const IColumn& column, size_t row_num, Arena* arena) {
+        this->change_first_time(column, row_num, arena);
     }
+    void change_if_better(const Self& to, Arena* arena) { this->change_first_time(to, arena); }
 
     static const char* name() { return "any"; }
 };
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
deleted file mode 100644
index 7d0dd084be..0000000000
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one
-// or more contributor license agreements.  See the NOTICE file
-// distributed with this work for additional information
-// regarding copyright ownership.  The ASF licenses this file
-// to you under the Apache License, Version 2.0 (the
-// "License"); you may not use this file except in compliance
-// with the License.  You may obtain a copy of the License at
-//
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing,
-// software distributed under the License is distributed on an
-// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-// KIND, either express or implied.  See the License for the
-// specific language governing permissions and limitations
-// under the License.
-
-#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
-
-#include "vec/aggregate_functions/aggregate_function_min_max.h"
-#include "vec/aggregate_functions/aggregate_function_simple_factory.h"
-#include "vec/aggregate_functions/factory_helpers.h"
-#include "vec/aggregate_functions/helpers.h"
-#include "vec/core/types.h"
-
-namespace doris::vectorized {
-
-/// min_by, max_by
-template <template <typename> class AggregateFunctionTemplate,
-          template <typename, typename> class Data, typename VT>
-AggregateFunctionPtr create_aggregate_function_min_max_by_impl(const DataTypes& argument_types,
-                                                               const bool result_is_nullable) {
-    WhichDataType which(remove_nullable(argument_types[1]));
-
-#define DISPATCH(TYPE)                                                            \
-    if (which.idx == TypeIndex::TYPE)                                             \
-        return creator_without_type::create<                                      \
-                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<TYPE>>>>( \
-                argument_types, result_is_nullable);
-    FOR_NUMERIC_TYPES(DISPATCH)
-#undef DISPATCH
-
-#define DISPATCH(TYPE)                                                              \
-    if (which.idx == TypeIndex::TYPE)                                               \
-        return creator_without_type::create<                                        \
-                AggregateFunctionTemplate<Data<VT, SingleValueDataDecimal<TYPE>>>>( \
-                argument_types, result_is_nullable);
-    FOR_DECIMAL_TYPES(DISPATCH)
-#undef DISPATCH
-
-    if (which.idx == TypeIndex::String) {
-        return creator_without_type::create<
-                AggregateFunctionTemplate<Data<VT, SingleValueDataString>>>(argument_types,
-                                                                            result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateTime || which.idx == TypeIndex::Date) {
-        return creator_without_type::create<
-                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<Int64>>>>(
-                argument_types, result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateV2) {
-        return creator_without_type::create<
-                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<UInt32>>>>(
-                argument_types, result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateTimeV2) {
-        return creator_without_type::create<
-                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<UInt64>>>>(
-                argument_types, result_is_nullable);
-    }
-    return nullptr;
-}
-
-/// min_by, max_by
-template <template <typename> class AggregateFunctionTemplate,
-          template <typename, typename> class Data>
-AggregateFunctionPtr create_aggregate_function_min_max_by(const String& name,
-                                                          const DataTypes& argument_types,
-                                                          const bool result_is_nullable) {
-    assert_binary(name, argument_types);
-
-    WhichDataType which(remove_nullable(argument_types[0]));
-#define DISPATCH(TYPE)                                                                    \
-    if (which.idx == TypeIndex::TYPE)                                                     \
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data, \
-                                                         SingleValueDataFixed<TYPE>>(     \
-                argument_types, result_is_nullable);
-    FOR_NUMERIC_TYPES(DISPATCH)
-#undef DISPATCH
-
-#define DISPATCH(TYPE)                                                                    \
-    if (which.idx == TypeIndex::TYPE)                                                     \
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data, \
-                                                         SingleValueDataDecimal<TYPE>>(   \
-                argument_types, result_is_nullable);
-    FOR_DECIMAL_TYPES(DISPATCH)
-#undef DISPATCH
-
-    if (which.idx == TypeIndex::String) {
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
-                                                         SingleValueDataString>(argument_types,
-                                                                                result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateTime || which.idx == TypeIndex::Date) {
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
-                                                         SingleValueDataFixed<Int64>>(
-                argument_types, result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateV2) {
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
-                                                         SingleValueDataFixed<UInt32>>(
-                argument_types, result_is_nullable);
-    }
-    if (which.idx == TypeIndex::DateTimeV2) {
-        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
-                                                         SingleValueDataFixed<UInt64>>(
-                argument_types, result_is_nullable);
-    }
-    return nullptr;
-}
-
-void register_aggregate_function_min_max_by(AggregateFunctionSimpleFactory& factory) {
-    factory.register_function_both(
-            "max_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
-                                                           AggregateFunctionMaxByData>);
-    factory.register_function_both(
-            "min_by", create_aggregate_function_min_max_by<AggregateFunctionsMinMaxBy,
-                                                           AggregateFunctionMinByData>);
-}
-
-} // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
index 28133dbb5d..69945facfc 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h
@@ -19,6 +19,8 @@
 
 #include "common/logging.h"
 #include "vec/aggregate_functions/aggregate_function.h"
+#include "vec/aggregate_functions/aggregate_function_min_max.h"
+#include "vec/aggregate_functions/helpers.h"
 #include "vec/columns/column_decimal.h"
 #include "vec/columns/column_vector.h"
 #include "vec/common/assert_cast.h"
@@ -52,21 +54,17 @@ public:
 template <typename VT, typename KT>
 struct AggregateFunctionMaxByData : public AggregateFunctionMinMaxByBaseData<VT, KT> {
     using Self = AggregateFunctionMaxByData;
-    bool change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
+    void change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
                           Arena* arena) {
         if (this->key.change_if_greater(key_column, row_num, arena)) {
             this->value.change(value_column, row_num, arena);
-            return true;
         }
-        return false;
     }
 
-    bool change_if_better(const Self& to, Arena* arena) {
+    void change_if_better(const Self& to, Arena* arena) {
         if (this->key.change_if_greater(to.key, arena)) {
             this->value.change(to.value, arena);
-            return true;
         }
-        return false;
     }
 
     static const char* name() { return "max_by"; }
@@ -75,21 +73,17 @@ struct AggregateFunctionMaxByData : public AggregateFunctionMinMaxByBaseData<VT,
 template <typename VT, typename KT>
 struct AggregateFunctionMinByData : public AggregateFunctionMinMaxByBaseData<VT, KT> {
     using Self = AggregateFunctionMinByData;
-    bool change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
+    void change_if_better(const IColumn& value_column, const IColumn& key_column, size_t row_num,
                           Arena* arena) {
         if (this->key.change_if_less(key_column, row_num, arena)) {
             this->value.change(value_column, row_num, arena);
-            return true;
         }
-        return false;
     }
 
-    bool change_if_better(const Self& to, Arena* arena) {
+    void change_if_better(const Self& to, Arena* arena) {
         if (this->key.change_if_less(to.key, arena)) {
             this->value.change(to.value, arena);
-            return true;
         }
-        return false;
     }
 
     static const char* name() { return "min_by"; }
@@ -144,12 +138,94 @@ public:
     }
 };
 
-AggregateFunctionPtr create_aggregate_function_max_by(const std::string& name,
-                                                      const DataTypes& argument_types,
-                                                      const bool result_is_nullable);
+template <template <typename> class AggregateFunctionTemplate,
+          template <typename, typename> class Data, typename VT>
+AggregateFunctionPtr create_aggregate_function_min_max_by_impl(const DataTypes& argument_types,
+                                                               const bool result_is_nullable) {
+    WhichDataType which(remove_nullable(argument_types[1]));
 
-AggregateFunctionPtr create_aggregate_function_min_by(const std::string& name,
-                                                      const DataTypes& argument_types,
-                                                      const bool result_is_nullable);
+#define DISPATCH(TYPE)                                                            \
+    if (which.idx == TypeIndex::TYPE)                                             \
+        return creator_without_type::create<                                      \
+                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<TYPE>>>>( \
+                argument_types, result_is_nullable);
+    FOR_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+#define DISPATCH(TYPE)                                                              \
+    if (which.idx == TypeIndex::TYPE)                                               \
+        return creator_without_type::create<                                        \
+                AggregateFunctionTemplate<Data<VT, SingleValueDataDecimal<TYPE>>>>( \
+                argument_types, result_is_nullable);
+    FOR_DECIMAL_TYPES(DISPATCH)
+#undef DISPATCH
+
+    if (which.idx == TypeIndex::String) {
+        return creator_without_type::create<
+                AggregateFunctionTemplate<Data<VT, SingleValueDataString>>>(argument_types,
+                                                                            result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateTime || which.idx == TypeIndex::Date) {
+        return creator_without_type::create<
+                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<Int64>>>>(
+                argument_types, result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateV2) {
+        return creator_without_type::create<
+                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<UInt32>>>>(
+                argument_types, result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateTimeV2) {
+        return creator_without_type::create<
+                AggregateFunctionTemplate<Data<VT, SingleValueDataFixed<UInt64>>>>(
+                argument_types, result_is_nullable);
+    }
+    return nullptr;
+}
+
+template <template <typename> class AggregateFunctionTemplate,
+          template <typename, typename> class Data>
+AggregateFunctionPtr create_aggregate_function_min_max_by(const String& name,
+                                                          const DataTypes& argument_types,
+                                                          const bool result_is_nullable) {
+    WhichDataType which(remove_nullable(argument_types[0]));
+#define DISPATCH(TYPE)                                                                    \
+    if (which.idx == TypeIndex::TYPE)                                                     \
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data, \
+                                                         SingleValueDataFixed<TYPE>>(     \
+                argument_types, result_is_nullable);
+    FOR_NUMERIC_TYPES(DISPATCH)
+#undef DISPATCH
+
+#define DISPATCH(TYPE)                                                                    \
+    if (which.idx == TypeIndex::TYPE)                                                     \
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data, \
+                                                         SingleValueDataDecimal<TYPE>>(   \
+                argument_types, result_is_nullable);
+    FOR_DECIMAL_TYPES(DISPATCH)
+#undef DISPATCH
+
+    if (which.idx == TypeIndex::String) {
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
+                                                         SingleValueDataString>(argument_types,
+                                                                                result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateTime || which.idx == TypeIndex::Date) {
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
+                                                         SingleValueDataFixed<Int64>>(
+                argument_types, result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateV2) {
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
+                                                         SingleValueDataFixed<UInt32>>(
+                argument_types, result_is_nullable);
+    }
+    if (which.idx == TypeIndex::DateTimeV2) {
+        return create_aggregate_function_min_max_by_impl<AggregateFunctionTemplate, Data,
+                                                         SingleValueDataFixed<UInt64>>(
+                argument_types, result_is_nullable);
+    }
+    return nullptr;
+}
 
 } // namespace doris::vectorized
diff --git a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
index 2ce9fcd820..5649438cdd 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_simple_factory.cpp
@@ -31,7 +31,8 @@ void register_aggregate_function_combinator_distinct(AggregateFunctionSimpleFact
 
 void register_aggregate_function_sum(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_minmax(AggregateFunctionSimpleFactory& factory);
-void register_aggregate_function_min_max_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_avg(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_count(AggregateFunctionSimpleFactory& factory);
 void register_aggregate_function_HLL_union_agg(AggregateFunctionSimpleFactory& factory);
@@ -63,7 +64,8 @@ AggregateFunctionSimpleFactory& AggregateFunctionSimpleFactory::instance() {
     std::call_once(oc, [&]() {
         register_aggregate_function_sum(instance);
         register_aggregate_function_minmax(instance);
-        register_aggregate_function_min_max_by(instance);
+        register_aggregate_function_min_by(instance);
+        register_aggregate_function_max_by(instance);
         register_aggregate_function_avg(instance);
         register_aggregate_function_count(instance);
         register_aggregate_function_uniq(instance);
diff --git a/be/src/vec/functions/function_date_or_datetime_computation_v2.cpp b/be/src/vec/functions/function_date_or_datetime_computation_v2.cpp
index eb89ffab34..af7db77a9b 100644
--- a/be/src/vec/functions/function_date_or_datetime_computation_v2.cpp
+++ b/be/src/vec/functions/function_date_or_datetime_computation_v2.cpp
@@ -89,10 +89,6 @@ using FunctionDatetimeV2SubYears =
     FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateTimeV2, DataTypeDateTimeV2) \
     FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateTimeV2, DataTypeDateV2)     \
     FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateV2, DataTypeDateTimeV2)     \
-    FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateTimeV2, DataTypeDateTime)   \
-    FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateTime, DataTypeDateTimeV2)   \
-    FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateTime, DataTypeDateV2)       \
-    FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateV2, DataTypeDateTime)       \
     FUNCTION_DATEV2_WITH_TWO_ARGS(NAME, IMPL, DataTypeDateV2, DataTypeDateV2)
 
 ALL_FUNCTION_DATEV2_WITH_TWO_ARGS(FunctionDatetimeV2DateDiff, DateDiffImpl)
@@ -156,11 +152,7 @@ void register_function_date_time_computation_v2(SimpleFunctionFactory& factory)
     REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateTimeV2, DataTypeDateTimeV2) \
     REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateTimeV2, DataTypeDateV2)     \
     REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateV2, DataTypeDateTimeV2)     \
-    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateTimeV2, DataTypeDateTime)   \
-    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateV2, DataTypeDateTime)       \
-    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateV2, DataTypeDateV2)         \
-    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateTime, DataTypeDateV2)       \
-    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateTime, DataTypeDateTimeV2)
+    REGISTER_DATEV2_FUNCTIONS_WITH_TWO_ARGS(NAME, DataTypeDateV2, DataTypeDateV2)
 
     REGISTER_ALL_DATEV2_FUNCTIONS_WITH_TWO_ARGS(FunctionDatetimeV2DateDiff)
     REGISTER_ALL_DATEV2_FUNCTIONS_WITH_TWO_ARGS(FunctionDatetimeV2TimeDiff)
diff --git a/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp b/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
index 96b6e36a35..d1420307a2 100644
--- a/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
+++ b/be/test/vec/aggregate_functions/agg_min_max_by_test.cpp
@@ -20,7 +20,6 @@
 
 #include "gtest/gtest.h"
 #include "vec/aggregate_functions/aggregate_function.h"
-#include "vec/aggregate_functions/aggregate_function_min_max_by.h"
 #include "vec/aggregate_functions/aggregate_function_simple_factory.h"
 #include "vec/columns/column_vector.h"
 #include "vec/data_types/data_type.h"
@@ -31,7 +30,8 @@ const int agg_test_batch_size = 4096;
 
 namespace doris::vectorized {
 // declare function
-void register_aggregate_function_min_max_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_min_by(AggregateFunctionSimpleFactory& factory);
+void register_aggregate_function_max_by(AggregateFunctionSimpleFactory& factory);
 
 class AggMinMaxByTest : public ::testing::TestWithParam<std::string> {};
 
@@ -60,7 +60,8 @@ TEST_P(AggMinMaxByTest, min_max_by_test) {
 
     // Prepare test function and parameters.
     AggregateFunctionSimpleFactory factory;
-    register_aggregate_function_min_max_by(factory);
+    register_aggregate_function_min_by(factory);
+    register_aggregate_function_max_by(factory);
 
     // Test on 2 kind of key types (int32, string).
     for (int i = 0; i < 2; i++) {
diff --git a/be/test/vec/function/function_time_test.cpp b/be/test/vec/function/function_time_test.cpp
index 8a68a608b8..d942009a02 100644
--- a/be/test/vec/function/function_time_test.cpp
+++ b/be/test/vec/function/function_time_test.cpp
@@ -852,51 +852,6 @@ TEST(VTimestampFunctionsTest, timediff_v2_test) {
         check_function<DataTypeTime, true>(func_name, input_types, data_set);
     }
 
-    {
-        InputTypeSet input_types = {TypeIndex::DateV2, TypeIndex::Date};
-
-        DataSet data_set = {{{std::string("2019-07-18"), std::string("2019-07-18")}, 0.0},
-                            {{std::string("2019-07-18"), std::string("2019-07-18")}, -0.0},
-                            {{std::string("2019-00-18"), std::string("2019-07-18")}, Null()},
-                            {{std::string("2019-07-18"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::Date, TypeIndex::DateV2};
-
-        DataSet data_set = {{{std::string("2019-07-18"), std::string("2019-07-18")}, 0.0},
-                            {{std::string("2019-07-18"), std::string("2019-07-18")}, -0.0},
-                            {{std::string("2019-00-18"), std::string("2019-07-18")}, Null()},
-                            {{std::string("2019-07-18"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::DateV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-18")}, 0.0},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-18")}, -0.0},
-                {{std::string("2019-00-18 00:00:00"), std::string("2019-07-18")}, Null()},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateV2, TypeIndex::DateTime};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18"), std::string("2019-07-18 00:00:00")}, 0.0},
-                {{std::string("2019-07-18"), std::string("2019-07-18 00:00:00")}, -0.0},
-                {{std::string("2019-00-18"), std::string("2019-07-18 00:00:00")}, Null()},
-                {{std::string("2019-07-18"), std::string("2019-07-00 00:00:00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
     {
         InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::DateTimeV2};
 
@@ -908,57 +863,6 @@ TEST(VTimestampFunctionsTest, timediff_v2_test) {
 
         check_function<DataTypeTime, true>(func_name, input_types, data_set);
     }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::Date};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-18")}, 0.0},
-                {{std::string("2019-07-18 00:00:10"), std::string("2019-07-18")}, 10.0},
-                {{std::string("2019-00-18 00:00:00"), std::string("2019-07-18")}, Null()},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::Date, TypeIndex::DateTimeV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18"), std::string("2019-07-18 00:00:00")}, 0.0},
-                {{std::string("2019-07-18"), std::string("2019-07-18 00:00:10")}, -10.0},
-                {{std::string("2019-00-18"), std::string("2019-07-18 00:00:00")}, Null()},
-                {{std::string("2019-07-18"), std::string("2019-07-00 00:00:00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::DateTimeV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-18 00:00:00")}, 0.0},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-18 00:00:10")}, -10.0},
-                {{std::string("2019-00-18 00:00:00"), std::string("2019-07-18 00:00:00")}, Null()},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-00 00:00:00")}, Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::DateTime};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-18 00:00:00")}, 0.0},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-18 00:00:00")},
-                 -0.0},
-                {{std::string("2019-00-18 00:00:00.123"), std::string("2019-07-18 00:00:00")},
-                 Null()},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-00 00:00:00")},
-                 Null()}};
-
-        check_function<DataTypeTime, true>(func_name, input_types, data_set);
-    }
 }
 
 TEST(VTimestampFunctionsTest, datediff_v2_test) {
@@ -975,52 +879,6 @@ TEST(VTimestampFunctionsTest, datediff_v2_test) {
         check_function<DataTypeInt32, true>(func_name, input_types, data_set);
     }
 
-    {
-        InputTypeSet input_types = {TypeIndex::DateV2, TypeIndex::Date};
-
-        DataSet data_set = {{{std::string("2019-07-18"), std::string("2019-07-19")}, -1},
-                            {{std::string("2019-07-18"), std::string("2019-07-17")}, 1},
-                            {{std::string("2019-00-18"), std::string("2019-07-18")}, Null()},
-                            {{std::string("2019-07-18"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::Date, TypeIndex::DateV2};
-
-        DataSet data_set = {{{std::string("2019-07-18"), std::string("2019-07-19")}, -1},
-                            {{std::string("2019-07-18"), std::string("2019-07-17")}, 1},
-                            {{std::string("2019-00-18"), std::string("2019-07-18")}, Null()},
-                            {{std::string("2019-07-18"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::DateV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-19")}, -1},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-17")}, 1},
-                {{std::string("2019-00-18 00:00:00"), std::string("2019-07-18")}, Null()},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateV2, TypeIndex::DateTime};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18"), std::string("2019-07-19 00:00:00")}, -1},
-                {{std::string("2019-07-18"), std::string("2019-07-17 00:00:00")}, 1},
-                {{std::string("2019-00-18"), std::string("2019-07-18 00:00:00")}, Null()},
-                {{std::string("2019-07-18"), std::string("2019-07-00 00:00:00")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
     {
         InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::DateV2};
 
@@ -1032,58 +890,6 @@ TEST(VTimestampFunctionsTest, datediff_v2_test) {
 
         check_function<DataTypeInt32, true>(func_name, input_types, data_set);
     }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::Date};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-19")}, -1},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-17")}, 1},
-                {{std::string("2019-00-18 00:00:00.123"), std::string("2019-07-18")}, Null()},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-00")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::Date, TypeIndex::DateTimeV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18"), std::string("2019-07-19 00:00:00.123")}, -1},
-                {{std::string("2019-07-18"), std::string("2019-07-17 00:00:00.123")}, 1},
-                {{std::string("2019-00-18"), std::string("2019-07-18 00:00:00.123")}, Null()},
-                {{std::string("2019-07-18"), std::string("2019-07-00 00:00:00.123")}, Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTime, TypeIndex::DateTimeV2};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-19 00:00:00.123")}, -1},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-17 00:00:00.123")}, 1},
-                {{std::string("2019-00-18 00:00:00"), std::string("2019-07-18 00:00:00.123")},
-                 Null()},
-                {{std::string("2019-07-18 00:00:00"), std::string("2019-07-00 00:00:00.123")},
-                 Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
-
-    {
-        InputTypeSet input_types = {TypeIndex::DateTimeV2, TypeIndex::DateTime};
-
-        DataSet data_set = {
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-19 00:00:00")}, -1},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-17 00:00:00")}, 1},
-                {{std::string("2019-00-18 00:00:00.123"), std::string("2019-07-18 00:00:00")},
-                 Null()},
-                {{std::string("2019-07-18 00:00:00.123"), std::string("2019-07-00 00:00:00")},
-                 Null()}};
-
-        check_function<DataTypeInt32, true>(func_name, input_types, data_set);
-    }
 }
 
 TEST(VTimestampFunctionsTest, date_format_v2_test) {
diff --git a/build.sh b/build.sh
index f3d62295ef..88b9ebc37c 100755
--- a/build.sh
+++ b/build.sh
@@ -300,6 +300,10 @@ if [[ -z "${USE_DWARF}" ]]; then
     USE_DWARF='OFF'
 fi
 
+if [[ -z "${DISPLAY_BUILD_TIME}" ]]; then
+    DISPLAY_BUILD_TIME='OFF'
+fi
+
 if [[ -z "${OUTPUT_BE_BINARY}" ]]; then
     OUTPUT_BE_BINARY=${BUILD_BE}
 fi
@@ -362,6 +366,7 @@ echo "Get params:
     USE_BTHREAD_SCANNER -- ${USE_BTHREAD_SCANNER}
     ENABLE_STACKTRACE   -- ${ENABLE_STACKTRACE}
     DENABLE_CLANG_COVERAGE -- ${DENABLE_CLANG_COVERAGE}
+    DISPLAY_BUILD_TIME  -- ${DISPLAY_BUILD_TIME}
 "
 
 # Clean and build generated code
@@ -429,6 +434,7 @@ if [[ "${BUILD_BE}" -eq 1 ]]; then
         -DBUILD_META_TOOL="${BUILD_META_TOOL}" \
         -DSTRIP_DEBUG_INFO="${STRIP_DEBUG_INFO}" \
         -DUSE_DWARF="${USE_DWARF}" \
+        -DDISPLAY_BUILD_TIME="${DISPLAY_BUILD_TIME}" \
         -DUSE_MEM_TRACKER="${USE_MEM_TRACKER}" \
         -DUSE_JEMALLOC="${USE_JEMALLOC}" \
         -DUSE_BTHREAD_SCANNER="${USE_BTHREAD_SCANNER}" \
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DateDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DateDiff.java
index 7e1c2788e7..af52b494e4 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DateDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DateDiff.java
@@ -45,9 +45,7 @@ public class DateDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(IntegerType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
             FunctionSignature.ret(IntegerType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
-            FunctionSignature.ret(IntegerType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(IntegerType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(IntegerType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE)
+            FunctionSignature.ret(IntegerType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DaysDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DaysDiff.java
index dd7251c8f9..7cba92b10b 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DaysDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/DaysDiff.java
@@ -45,11 +45,7 @@ public class DaysDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/HoursDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/HoursDiff.java
index f6c1a6d50b..354b163821 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/HoursDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/HoursDiff.java
@@ -45,11 +45,7 @@ public class HoursDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinutesDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinutesDiff.java
index 23954daf12..b4f86a1352 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinutesDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MinutesDiff.java
@@ -45,11 +45,7 @@ public class MinutesDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MonthsDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MonthsDiff.java
index aae98eff6f..b42017b3d0 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MonthsDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MonthsDiff.java
@@ -45,11 +45,7 @@ public class MonthsDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/SecondsDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/SecondsDiff.java
index 7635e40483..cd07e6fff0 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/SecondsDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/SecondsDiff.java
@@ -45,11 +45,7 @@ public class SecondsDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
index 683631b3f1..8e6652686e 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/TimeDiff.java
@@ -46,9 +46,7 @@ public class TimeDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
             FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
-            FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE)
+            FunctionSignature.ret(TimeV2Type.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/WeeksDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/WeeksDiff.java
index 4d512ba485..b4bd09e042 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/WeeksDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/WeeksDiff.java
@@ -45,11 +45,7 @@ public class WeeksDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/YearsDiff.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/YearsDiff.java
index 5c05ed5e88..f52cdaa105 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/YearsDiff.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/YearsDiff.java
@@ -45,11 +45,7 @@ public class YearsDiff extends ScalarFunction
                     .args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT),
             FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateV2Type.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeV2Type.SYSTEM_DEFAULT, DateTimeType.INSTANCE),
-            FunctionSignature.ret(BigIntType.INSTANCE).args(DateTimeType.INSTANCE, DateTimeV2Type.SYSTEM_DEFAULT)
+            FunctionSignature.ret(BigIntType.INSTANCE).args(DateV2Type.INSTANCE, DateV2Type.INSTANCE)
     );
 
     /**