HappenLee commented on code in PR #45265:
URL: https://github.com/apache/doris/pull/45265#discussion_r1889794172

##########
be/src/vec/functions/function_date_or_datetime_computation.h:
##########
@@ -318,381 +278,114 @@ struct TimeDiffImpl {
 #define TIME_DIFF_FUNCTION_IMPL(CLASS, NAME, UNIT) \
     DECLARE_DATE_FUNCTIONS(CLASS, NAME, DataTypeInt64, 
datetime_diff<TimeUnit::UNIT>(ts1, ts0))
 
+// all these functions implemented by datediff
 TIME_DIFF_FUNCTION_IMPL(YearsDiffImpl, years_diff, YEAR);
 TIME_DIFF_FUNCTION_IMPL(MonthsDiffImpl, months_diff, MONTH);
 TIME_DIFF_FUNCTION_IMPL(WeeksDiffImpl, weeks_diff, WEEK);
 TIME_DIFF_FUNCTION_IMPL(DaysDiffImpl, days_diff, DAY);
 TIME_DIFF_FUNCTION_IMPL(HoursDiffImpl, hours_diff, HOUR);
-TIME_DIFF_FUNCTION_IMPL(MintueSDiffImpl, minutes_diff, MINUTE);
+TIME_DIFF_FUNCTION_IMPL(MintuesDiffImpl, minutes_diff, MINUTE);
 TIME_DIFF_FUNCTION_IMPL(SecondsDiffImpl, seconds_diff, SECOND);
 TIME_DIFF_FUNCTION_IMPL(MilliSecondsDiffImpl, milliseconds_diff, MILLISECOND);
 TIME_DIFF_FUNCTION_IMPL(MicroSecondsDiffImpl, microseconds_diff, MICROSECOND);
 
-#define TIME_FUNCTION_TWO_ARGS_IMPL(CLASS, NAME, FUNCTION, RETURN_TYPE)        
                   \
-    template <typename DateType>                                               
                   \
-    struct CLASS {                                                             
                   \
-        using ArgType = std::conditional_t<                                    
                   \
-                std::is_same_v<DateType, DataTypeDateV2>, UInt32,              
                   \
-                std::conditional_t<std::is_same_v<DateType, 
DataTypeDateTimeV2>, UInt64, Int64>>; \
-        using DateValueType = std::conditional_t<                              
                   \
-                std::is_same_v<DateType, DataTypeDateV2>, 
DateV2Value<DateV2ValueType>,           \
-                std::conditional_t<std::is_same_v<DateType, 
DataTypeDateTimeV2>,                  \
-                                   DateV2Value<DateTimeV2ValueType>, 
VecDateTimeValue>>;          \
-        using ReturnType = RETURN_TYPE;                                        
                   \
-        static constexpr auto name = #NAME;                                    
                   \
-        static constexpr auto is_nullable = false;                             
                   \
-        static inline ReturnType::FieldType execute(const ArgType& t0, const 
Int32 mode,          \
-                                                    bool& is_null) {           
                   \
-            const auto& ts0 = reinterpret_cast<const DateValueType&>(t0);      
                   \
-            is_null = !ts0.is_valid_date();                                    
                   \
-            return ts0.FUNCTION;                                               
                   \
-        }                                                                      
                   \
-        static DataTypes get_variadic_argument_types() {                       
                   \
-            return {std::make_shared<DateType>(), 
std::make_shared<DataTypeInt32>()};             \
-        }                                                                      
                   \
+#define TIME_FUNCTION_TWO_ARGS_IMPL(CLASS, NAME, FUNCTION, RETURN_TYPE)        
            \
+    template <typename DateType>                                               
            \
+    struct CLASS {                                                             
            \
+        using ArgType = 
date_cast::ValueTypeOfColumnV<date_cast::TypeToColumnV<DateType>>; \
+        using DateValueType = date_cast::TypeToValueTypeV<DateType>;           
            \
+        using ReturnType = RETURN_TYPE;                                        
            \
+                                                                               
            \
+        static constexpr auto name = #NAME;                                    
            \
+        static constexpr auto is_nullable = false;                             
            \
+        static inline ReturnType::FieldType execute(const ArgType& t0, const 
Int32 mode,   \
+                                                    bool& is_null) {           
            \
+            const auto& ts0 = reinterpret_cast<const DateValueType&>(t0);      
            \
+            is_null = !ts0.is_valid_date();                                    
            \
+            return ts0.FUNCTION;                                               
            \
+        }                                                                      
            \
+        static DataTypes get_variadic_argument_types() {                       
            \
+            return {std::make_shared<DateType>(), 
std::make_shared<DataTypeInt32>()};      \
+        }                                                                      
            \
     }
 
 TIME_FUNCTION_TWO_ARGS_IMPL(ToYearWeekTwoArgsImpl, yearweek, 
year_week(mysql_week_mode(mode)),
                             DataTypeInt32);
 TIME_FUNCTION_TWO_ARGS_IMPL(ToWeekTwoArgsImpl, week, 
week(mysql_week_mode(mode)), DataTypeInt8);
 
-template <typename FromType1, typename FromType2, typename ToType, typename 
Transform>
+// only use for FunctionDateOrDateTimeComputation
+template <typename FromType0, typename FromType1, typename ToType, typename 
Transform>
 struct DateTimeOp {
-    // use for (DateTime, DateTime) -> other_type
-    static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
-                              const PaddedPODArray<FromType2>& vec_from1,
-                              PaddedPODArray<ToType>& vec_to, NullMap& 
null_map) {
-        size_t size = vec_from0.size();
-        vec_to.resize(size);
-        null_map.resize_fill(size, false);
-
-        for (size_t i = 0; i < size; ++i) {
-            // here reinterpret_cast is used to convert uint8& to bool&,
-            // otherwise it will be implicitly converted to bool, causing the 
rvalue to fail to match the lvalue.
-            // the same goes for the following.
-            vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i],
-                                           
reinterpret_cast<bool&>(null_map[i]));
-        }
-    }
-    static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
-                              const PaddedPODArray<FromType2>& vec_from1,
-                              PaddedPODArray<ToType>& vec_to) {
+    static void vector_vector(const PaddedPODArray<FromType0>& vec_from0,
+                              const PaddedPODArray<FromType1>& vec_from1,
+                              PaddedPODArray<ToType>& vec_to, const NullMap* 
nullmap0,
+                              const NullMap* nullmap1) {
         size_t size = vec_from0.size();
         vec_to.resize(size);
+        bool invalid = false;
 
-        bool invalid = true;
         for (size_t i = 0; i < size; ++i) {
-            // here reinterpret_cast is used to convert uint8& to bool&,
-            // otherwise it will be implicitly converted to bool, causing the 
rvalue to fail to match the lvalue.
-            // the same goes for the following.
-            vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i], 
invalid);
-
-            if (UNLIKELY(invalid)) {
-                throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} {} {} 
out of range",
-                                Transform::name, vec_from0[i], vec_from1[i]);
+            if ((nullmap0 && (*nullmap0)[i]) || (nullmap1 && (*nullmap1)[i])) 
[[unlikely]] {
+                continue;
             }
-        }
-    }
-
-    // use for (DateTime, int32) -> other_type
-    static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
-                              const PaddedPODArray<Int32>& vec_from1,
-                              PaddedPODArray<ToType>& vec_to, NullMap& 
null_map) {
-        size_t size = vec_from0.size();
-        vec_to.resize(size);
-        null_map.resize_fill(size, false);
-
-        for (size_t i = 0; i < size; ++i)
-            vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i],
-                                           
reinterpret_cast<bool&>(null_map[i]));
-    }
-    static void vector_vector(const PaddedPODArray<FromType1>& vec_from0,
-                              const PaddedPODArray<Int32>& vec_from1,
-                              PaddedPODArray<ToType>& vec_to) {
-        size_t size = vec_from0.size();
-        vec_to.resize(size);
-
-        bool invalid = true;
-        for (size_t i = 0; i < size; ++i) {
             vec_to[i] = Transform::execute(vec_from0[i], vec_from1[i], 
invalid);
 
             if (UNLIKELY(invalid)) {
-                throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} {} {} 
out of range",
+                throw Exception(ErrorCode::OUT_OF_BOUND, "Operation {} of {} 
{} out of range",

Review Comment:
   format the `vec_from0[i]`



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org

Reply via email to