[env](compile)open compile check in some function agg file (#44549)

### What problem does this PR solve?

This is part of the changes because modifying too much at once can
easily cause conflicts with other PRs.

be/src/vec/aggregate_functions/aggregate_function.h

@@ -36,6 +36,7 @@
 #include "vec/data_types/data_type_string.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 class Arena;
 class IColumn;
@@ -598,3 +599,5 @@ class AggregateFunctionGuard {
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.cpp

@@ -29,6 +29,7 @@
 #include "vec/functions/function.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 AggregateFunctionPtr create_aggregate_function_approx_count_distinct(
         const std::string& name, const DataTypes& argument_types, const bool result_is_nullable,

be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.h

@@ -38,6 +38,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -64,8 +65,7 @@ struct AggregateFunctionApproxCountDistinctData {
     void write(BufferWritable& buf) const {
         std::string result;
         result.resize(hll_data.max_serialized_size());
-        int size = hll_data.serialize((uint8_t*)result.data());
-        result.resize(size);
+        result.resize(hll_data.serialize((uint8_t*)result.data()));
         write_binary(result, buf);
     }
 
@@ -136,3 +136,5 @@ class AggregateFunctionApproxCountDistinct final
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_avg.cpp

@@ -25,6 +25,7 @@
 #include "vec/core/field.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <typename T>
 struct Avg {

be/src/vec/aggregate_functions/aggregate_function_avg.h

@@ -41,6 +41,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -72,7 +73,8 @@ struct AggregateFunctionAvgData {
     ResultT result() const {
         if constexpr (std::is_floating_point_v<ResultT>) {
             if constexpr (std::numeric_limits<ResultT>::is_iec559) {
-                return static_cast<ResultT>(sum) / count; /// allow division by zero
+                return static_cast<ResultT>(sum) /
+                       static_cast<ResultT>(count); /// allow division by zero
             }
         }
 
@@ -91,7 +93,7 @@ struct AggregateFunctionAvgData {
             if constexpr (IsDecimal256<T>) {
                 return static_cast<ResultT>(sum / T(count));
             } else {
-                return static_cast<ResultT>(sum) / count;
+                return static_cast<ResultT>(sum) / static_cast<ResultT>(count);
             }
         }
     }
@@ -124,7 +126,11 @@ class AggregateFunctionAvg final
             IsDecimalV2<T>, ColumnDecimal<Decimal128V2>,
             std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<typename Data::ResultType>,
                                ColumnFloat64>>;
+    // The result calculated by PercentileApprox is an approximate value,
+    // so the underlying storage uses float. The following calls will involve
+    // an implicit cast to float.
 
+    using DataType = typename Data::ResultType;
     /// ctor for native types
     AggregateFunctionAvg(const DataTypes& argument_types_)
             : IAggregateFunctionDataHelper<Data, AggregateFunctionAvg<T, Data>>(argument_types_),
@@ -148,9 +154,9 @@ class AggregateFunctionAvg final
         const auto& column =
                 assert_cast<const ColVecType&, TypeCheckOnRelease::DISABLE>(*columns[0]);
         if constexpr (IsDecimalNumber<T>) {
-            this->data(place).sum += column.get_data()[row_num].value;
+            this->data(place).sum += (DataType)column.get_data()[row_num].value;
         } else {
-            this->data(place).sum += column.get_data()[row_num];
+            this->data(place).sum += (DataType)column.get_data()[row_num];
         }
         ++this->data(place).count;
     }
@@ -282,3 +288,5 @@ class AggregateFunctionAvg final
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_avg_weighted.cpp

@@ -21,6 +21,7 @@
 #include "vec/aggregate_functions/helpers.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 void register_aggregate_function_avg_weighted(AggregateFunctionSimpleFactory& factory) {
     factory.register_function_both("avg_weighted",
                                    creator_with_type::creator<AggregateFunctionAvgWeight>);

be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h

@@ -35,6 +35,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -57,7 +58,7 @@ struct AggregateFunctionAvgWeightedData {
             DecimalV2Value value = binary_cast<Int128, DecimalV2Value>(data_val);
             data_sum = data_sum + (double(value) * weight_val);
         } else {
-            data_sum = data_sum + (data_val * weight_val);
+            data_sum = data_sum + (double(data_val) * weight_val);
         }
         weight_sum = weight_sum + weight_val;
     }
@@ -138,3 +139,5 @@ class AggregateFunctionAvgWeight final
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_binary.h

@@ -36,6 +36,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <typename T1, typename T2, template <typename> typename Moments>
 struct StatFunc {
@@ -127,3 +128,5 @@ AggregateFunctionPtr create_with_two_basic_numeric_types(const DataTypePtr& firs
 }
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_bit.cpp

@@ -24,6 +24,7 @@
 #include "vec/aggregate_functions/helpers.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 void register_aggregate_function_bit(AggregateFunctionSimpleFactory& factory) {
     factory.register_function_both(

be/src/vec/aggregate_functions/aggregate_function_bit.h

@@ -30,6 +30,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -142,4 +143,5 @@ class AggregateFunctionBitwise final
     }
 };
 
-} // namespace doris::vectorized
+} // namespace doris::vectorized
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_bitmap.cpp

@@ -23,6 +23,7 @@
 #include "vec/data_types/data_type_nullable.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <bool nullable, template <bool, typename> class AggregateFunctionTemplate>
 AggregateFunctionPtr create_with_int_data_type(const DataTypes& argument_type) {
@@ -33,7 +34,11 @@ AggregateFunctionPtr create_with_int_data_type(const DataTypes& argument_type) {
         return std::make_shared<AggregateFunctionTemplate<nullable, ColumnVector<TYPE>>>( \
                 argument_type);                                                           \
     }
-    FOR_INTEGER_TYPES(DISPATCH)
+    // Keep consistent with the FE definition; the function does not have an int128 type.
+    DISPATCH(Int8)
+    DISPATCH(Int16)
+    DISPATCH(Int32)
+    DISPATCH(Int64)
 #undef DISPATCH
     LOG(WARNING) << "with unknowed type, failed in create_with_int_data_type bitmap_union_int"
                  << " and type is: " << argument_type[0]->get_name();

be/src/vec/aggregate_functions/aggregate_function_bitmap.h

@@ -38,6 +38,7 @@
 #include "vec/data_types/data_type_number.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -432,4 +433,5 @@ AggregateFunctionPtr create_aggregate_function_bitmap_union(const std::string& n
                                                             const DataTypes& argument_types,
                                                             const bool result_is_nullable);
 
-} // namespace doris::vectorized
+} // namespace doris::vectorized
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.cpp

@@ -23,6 +23,7 @@
 #include "vec/data_types/data_type_nullable.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <bool nullable>
 AggregateFunctionPtr create_with_int_data_type(const DataTypes& argument_types) {
@@ -32,7 +33,11 @@ AggregateFunctionPtr create_with_int_data_type(const DataTypes& argument_types)
     if (which.idx == TypeIndex::TYPE) {                                                      \
         return std::make_shared<AggregateFunctionBitmapAgg<nullable, TYPE>>(argument_types); \
     }
-    FOR_INTEGER_TYPES(DISPATCH)
+    // Keep consistent with the FE definition; the function does not have an int128 type.
+    DISPATCH(Int8)
+    DISPATCH(Int16)
+    DISPATCH(Int32)
+    DISPATCH(Int64)
 #undef DISPATCH
     LOG(WARNING) << "with unknown type, failed in create_with_int_data_type bitmap_union_int"
                  << " and type is: " << argument_types[0]->get_name();

be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.h

@@ -31,6 +31,7 @@
 #include "vec/data_types/data_type_bitmap.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -226,4 +227,5 @@ class AggregateFunctionBitmapAgg final
     }
 };
 
-} // namespace doris::vectorized
+} // namespace doris::vectorized
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_collect.cpp

@@ -26,6 +26,7 @@
 #include "vec/aggregate_functions/helpers.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <typename T, typename HasLimit, typename ShowNull>
 AggregateFunctionPtr do_create_agg_function_collect(bool distinct, const DataTypes& argument_types,

be/src/vec/aggregate_functions/aggregate_function_collect.h

@@ -46,6 +46,7 @@
 #include "vec/io/var_int.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 } // namespace vectorized
@@ -836,3 +837,5 @@ class AggregateFunctionCollect
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_combinator.h

@@ -26,6 +26,7 @@
 #include "vec/data_types/data_type.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 /** Aggregate function combinator allows to take one aggregate function
   *  and transform it to another aggregate function.
@@ -69,3 +70,5 @@ class IAggregateFunctionCombinator {
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_corr.cpp

@@ -21,6 +21,7 @@
 #include "vec/core/types.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <typename T>
 struct CorrMoment {

be/src/vec/aggregate_functions/aggregate_function_count.cpp

@@ -26,6 +26,7 @@
 #include "vec/aggregate_functions/factory_helpers.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 AggregateFunctionPtr create_aggregate_function_count(const std::string& name,
                                                      const DataTypes& argument_types,

be/src/vec/aggregate_functions/aggregate_function_count.h

@@ -41,6 +41,7 @@
 #include "vec/io/var_int.h"
 
 namespace doris {
+#include "common/compile_check_begin.h"
 namespace vectorized {
 class Arena;
 class BufferReadable;
@@ -321,3 +322,5 @@ class AggregateFunctionCountNotNullUnary final
 };
 
 } // namespace doris::vectorized
+
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_count_by_enum.cpp

@@ -26,6 +26,7 @@
 #include "vec/core/types.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 AggregateFunctionPtr create_aggregate_function_count_by_enum(const std::string& name,
                                                              const DataTypes& argument_types,

be/src/vec/aggregate_functions/aggregate_function_count_by_enum.h

@@ -32,6 +32,7 @@
 #include "vec/io/io_helper.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 struct CountByEnumData {
     std::unordered_map<std::string, uint64_t> cbe;
@@ -46,8 +47,7 @@ void build_json_from_vec(rapidjson::StringBuffer& buffer,
     doc.SetArray();
     rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
 
-    int vec_size_number = data_vec.size();
-    for (int idx = 0; idx < vec_size_number; ++idx) {
+    for (size_t idx = 0; idx < data_vec.size(); ++idx) {
         rapidjson::Value obj(rapidjson::kObjectType);
 
         rapidjson::Value obj_cbe(rapidjson::kObjectType);
@@ -239,4 +239,5 @@ class AggregateFunctionCountByEnum final
     size_t arg_count;
 };
 
-} // namespace doris::vectorized
+} // namespace doris::vectorized
+#include "common/compile_check_end.h"

be/src/vec/aggregate_functions/aggregate_function_covar.cpp

@@ -28,6 +28,7 @@
 #include "vec/data_types/data_type_nullable.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <template <typename> class Function, template <typename> class Data>
 AggregateFunctionPtr create_function_single_value(const String& name,

be/src/vec/aggregate_functions/aggregate_function_covar.h

@@ -75,11 +75,12 @@ struct BaseData {
         if (count == 1) {
             return 0.0;
         }
-        return sum_xy / count - sum_x * sum_y / (count * count);
+        return sum_xy / (double)count - sum_x * sum_y / ((double)count * (double)count);
     }
 
     double get_samp_result() const {
-        return sum_xy / (count - 1) - sum_x * sum_y / (count * (count - 1));
+        return sum_xy / double(count - 1) -
+               sum_x * sum_y / ((double)(count) * ((double)(count - 1)));
     }
 
     void merge(const BaseData& rhs) {
@@ -95,10 +96,10 @@ struct BaseData {
     void add(const IColumn* column_x, const IColumn* column_y, size_t row_num) {
         const auto& sources_x =
                 assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_x);
-        double source_data_x = sources_x.get_data()[row_num];
+        double source_data_x = double(sources_x.get_data()[row_num]);
         const auto& sources_y =
                 assert_cast<const ColumnVector<T>&, TypeCheckOnRelease::DISABLE>(*column_y);
-        double source_data_y = sources_y.get_data()[row_num];
+        double source_data_y = double(sources_y.get_data()[row_num]);
 
         sum_x += source_data_x;
         sum_y += source_data_y;

be/src/vec/aggregate_functions/aggregate_function_distinct.cpp

@@ -28,6 +28,7 @@
 #include "vec/data_types/data_type_nullable.h"
 
 namespace doris::vectorized {
+#include "common/compile_check_begin.h"
 
 template <typename T>
 struct Reducer {