diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp b/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp
index ee255bc6cf3cb6..9c635fe136665d 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_union.cpp
@@ -27,10 +27,11 @@
 
 namespace doris::vectorized {
 
-template <typename T, template<typename> class StatFunctionTemplate>
-AggregateFunctionPtr type_dispatch_for_aggregate_function_regr(
-        const DataTypes& argument_types, const bool& result_is_nullable, bool y_nullable_input,
-        bool x_nullable_input) {
+template <typename T, template <typename> class StatFunctionTemplate>
+AggregateFunctionPtr type_dispatch_for_aggregate_function_regr(const DataTypes& argument_types,
+                                                               const bool& result_is_nullable,
+                                                               bool y_nullable_input,
+                                                               bool x_nullable_input) {
     if (y_nullable_input) {
         if (x_nullable_input) {
             return creator_without_type::create_ignore_nullable<
@@ -54,7 +55,7 @@ AggregateFunctionPtr type_dispatch_for_aggregate_function_regr(
     }
 }
 
-template <template<typename> class StatFunctionTemplate>
+template <template <typename> class StatFunctionTemplate>
 AggregateFunctionPtr create_aggregate_function_regr(const std::string& name,
                                                     const DataTypes& argument_types,
                                                     const bool result_is_nullable) {
@@ -72,8 +73,8 @@ AggregateFunctionPtr create_aggregate_function_regr(const std::string& name,
     WhichDataType y_type(remove_nullable(argument_types[0]));
     WhichDataType x_type(remove_nullable(argument_types[1]));
 
-#define DISPATCH(TYPE)                                                    \
-    if (x_type.idx == TypeIndex::TYPE && y_type.idx == TypeIndex::TYPE)   \
+#define DISPATCH(TYPE)                                                                \
+    if (x_type.idx == TypeIndex::TYPE && y_type.idx == TypeIndex::TYPE)               \
         return type_dispatch_for_aggregate_function_regr<TYPE, StatFunctionTemplate>( \
                 argument_types, result_is_nullable, y_nullable_input, x_nullable_input);
     FOR_NUMERIC_TYPES(DISPATCH)
diff --git a/be/src/vec/aggregate_functions/aggregate_function_regr_union.h b/be/src/vec/aggregate_functions/aggregate_function_regr_union.h
index 0296b2f800a245..e2460c0a8a6ae6 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_regr_union.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_regr_union.h
@@ -40,10 +40,10 @@ namespace doris::vectorized {
 template <typename T>
 struct AggregateFunctionRegrData {
     UInt64 count = 0;
-    Float64 sum_x{};
-    Float64 sum_y{};
-    Float64 sum_of_x_mul_y{};
-    Float64 sum_of_x_squared{};
+    Float64 sum_x {};
+    Float64 sum_y {};
+    Float64 sum_of_x_mul_y {};
+    Float64 sum_of_x_squared {};
 
     void write(BufferWritable& buf) const {
         write_binary(sum_x, buf);
@@ -90,36 +90,32 @@ struct AggregateFunctionRegrData {
 };
 
 template <typename T>
-struct RegrSlopeFunc {
+struct RegrSlopeFunc : AggregateFunctionRegrData<T> {
     using Type = T;
-    using Data = AggregateFunctionRegrData<Type>;
     static constexpr const char* name = "regr_slope";
 
-    template <typename Data>
-    static Float64 get_result(const Data& data) {
-        Float64 denominator = data.count * data.sum_of_x_squared - data.sum_x * data.sum_x;
-        if (data.count < 2 || denominator == 0.0) {
+    Float64 get_result() const {
+        Float64 denominator = this->count * this->sum_of_x_squared - this->sum_x * this->sum_x;
+        if (this->count < 2 || denominator == 0.0) {
             return std::numeric_limits<Float64>::quiet_NaN();
         }
-        Float64 slope = (data.count * data.sum_of_x_mul_y - data.sum_x * data.sum_y) / denominator;
+        Float64 slope = (this->count * this->sum_of_x_mul_y - this->sum_x * this->sum_y) / denominator;
         return slope;
     }
 };
 
 template <typename T>
-struct RegrInterceptFunc {
+struct RegrInterceptFunc : AggregateFunctionRegrData<T> {
     using Type = T;
-    using Data = AggregateFunctionRegrData<Type>;
     static constexpr const char* name = "regr_intercept";
 
-    template <typename Data>
-    static Float64 get_result(const Data& data) {
-        Float64 denominator = data.count * data.sum_of_x_squared - data.sum_x * data.sum_x;
-        if (data.count < 2 || denominator == 0.0) {
+    Float64 get_result() const {
+        Float64 denominator = this->count * this->sum_of_x_squared - this->sum_x * this->sum_x;
+        if (this->count < 2 || denominator == 0.0) {
             return std::numeric_limits<Float64>::quiet_NaN();
         }
-        Float64 slope = (data.count * data.sum_of_x_mul_y - data.sum_x * data.sum_y) / denominator;
-        Float64 intercept = (data.sum_y - slope * data.sum_x) / data.count;
+        Float64 slope = (this->count * this->sum_of_x_mul_y - this->sum_x * this->sum_y) / denominator;
+        Float64 intercept = (this->sum_y - slope * this->sum_x) / this->count;
         return intercept;
     }
 };
@@ -127,7 +123,7 @@ struct RegrInterceptFunc {
 template <typename RegrFunc, bool y_nullable, bool x_nullable>
 class AggregateFunctionRegrSimple
         : public IAggregateFunctionDataHelper<
-                  typename RegrFunc::Data,
+                  RegrFunc,
                   AggregateFunctionRegrSimple<RegrFunc, y_nullable, x_nullable>> {
 public:
     using Type = typename RegrFunc::Type;
@@ -137,7 +133,7 @@ class AggregateFunctionRegrSimple
 
     explicit AggregateFunctionRegrSimple(const DataTypes& argument_types_)
             : IAggregateFunctionDataHelper<
-                      typename RegrFunc::Data,
+                      RegrFunc,
                       AggregateFunctionRegrSimple<RegrFunc, y_nullable, x_nullable>>(
                       argument_types_) {
         DCHECK(!argument_types_.empty());
@@ -208,7 +204,7 @@ class AggregateFunctionRegrSimple
         const auto& data = this->data(place);
         auto& dst_column_with_nullable = assert_cast<ColumnNullable&>(to);
         auto& dst_column = assert_cast<ResultCol&>(dst_column_with_nullable.get_nested_column());
-        Float64 result = RegrFunc::get_result(data);
+        Float64 result = data.get_result();
         if (std::isnan(result)) {
             dst_column_with_nullable.get_null_map_data().push_back(1);
             dst_column.insert_default();