diff --git a/be/src/vec/aggregate_functions/aggregate_function_covar.h b/be/src/vec/aggregate_functions/aggregate_function_covar.h
index 179e723285e900..9b4b1b70c1fa7f 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_covar.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_covar.h
@@ -120,8 +120,6 @@ struct BaseData {
         count += 1;
     }
 
-    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
-
     double sum_x;
     double sum_y;
     double sum_xy;
@@ -134,6 +132,7 @@ struct PopData : Data {
         auto& col = assert_cast<ColumnFloat64&>(to);
         col.get_data().push_back(this->get_pop_result());
     }
+    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
 };
 
 template <typename T, typename Data>
@@ -148,6 +147,9 @@ struct SampData_OLDER : Data {
             nullable_column.get_null_map_data().push_back(0);
         }
     }
+    static DataTypePtr get_return_type() {
+        return make_nullable(std::make_shared<DataTypeNumber<Float64>>());
+    }
 };
 
 template <typename T, typename Data>
@@ -160,6 +162,7 @@ struct SampData : Data {
             col.get_data().push_back(this->get_samp_result());
         }
     }
+    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
 };
 
 template <typename Data>
@@ -184,17 +187,7 @@ class AggregateFunctionSampCovariance
 
     String get_name() const override { return Data::name(); }
 
-    DataTypePtr get_return_type() const override {
-        if constexpr (is_pop) {
-            return Data::get_return_type();
-        } else {
-            if (IAggregateFunction::version < AGG_FUNCTION_NULLABLE) {
-                return make_nullable(Data::get_return_type());
-            } else {
-                return Data::get_return_type();
-            }
-        }
-    }
+    DataTypePtr get_return_type() const override { return Data::get_return_type(); }
 
     void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
              Arena*) const override {
diff --git a/be/src/vec/aggregate_functions/aggregate_function_percentile.h b/be/src/vec/aggregate_functions/aggregate_function_percentile.h
index 5217ba5aeb5838..1c8a12340d7096 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_percentile.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_percentile.h
@@ -162,13 +162,6 @@ class AggregateFunctionPercentileApprox
 
     String get_name() const override { return "percentile_approx"; }
 
-    DataTypePtr get_return_type() const override {
-        if (IAggregateFunction::version < AGG_FUNCTION_NULLABLE) {
-            return make_nullable(std::make_shared<DataTypeFloat64>());
-        }
-        return std::make_shared<DataTypeFloat64>();
-    }
-
     void reset(AggregateDataPtr __restrict place) const override {
         AggregateFunctionPercentileApprox::data(place).reset();
     }
@@ -187,30 +180,6 @@ class AggregateFunctionPercentileApprox
                      Arena*) const override {
         AggregateFunctionPercentileApprox::data(place).read(buf);
     }
-
-    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
-        if (IAggregateFunction::version < AGG_FUNCTION_NULLABLE) {
-            ColumnNullable& nullable_column = assert_cast<ColumnNullable&>(to);
-            double result = AggregateFunctionPercentileApprox::data(place).get();
-
-            if (std::isnan(result)) {
-                nullable_column.insert_default();
-            } else {
-                auto& col = assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
-                col.get_data().push_back(result);
-                nullable_column.get_null_map_data().push_back(0);
-            }
-        } else {
-            auto& col = assert_cast<ColumnFloat64&>(to);
-            double result = AggregateFunctionPercentileApprox::data(place).get();
-
-            if (std::isnan(result)) {
-                col.insert_default();
-            } else {
-                col.get_data().push_back(result);
-            }
-        }
-    }
 };
 
 template <bool is_nullable>
@@ -256,6 +225,23 @@ class AggregateFunctionPercentileApproxTwoParams_OLDER : public AggregateFunctio
             this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num));
         }
     }
+
+    DataTypePtr get_return_type() const override {
+        return make_nullable(std::make_shared<DataTypeFloat64>());
+    }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& nullable_column = assert_cast<ColumnNullable&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            nullable_column.insert_default();
+        } else {
+            auto& col = assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
+            col.get_data().push_back(result);
+            nullable_column.get_null_map_data().push_back(0);
+        }
+    }
 };
 
 class AggregateFunctionPercentileApproxTwoParams : public AggregateFunctionPercentileApprox {
@@ -271,6 +257,19 @@ class AggregateFunctionPercentileApproxTwoParams : public AggregateFunctionPerce
         this->data(place).init();
         this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num));
     }
+
+    DataTypePtr get_return_type() const override { return std::make_shared<DataTypeFloat64>(); }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            col.insert_default();
+        } else {
+            col.get_data().push_back(result);
+        }
+    }
 };
 
 template <bool is_nullable>
@@ -319,6 +318,23 @@ class AggregateFunctionPercentileApproxThreeParams_OLDER
             this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num));
         }
     }
+
+    DataTypePtr get_return_type() const override {
+        return make_nullable(std::make_shared<DataTypeFloat64>());
+    }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& nullable_column = assert_cast<ColumnNullable&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            nullable_column.insert_default();
+        } else {
+            auto& col = assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
+            col.get_data().push_back(result);
+            nullable_column.get_null_map_data().push_back(0);
+        }
+    }
 };
 
 class AggregateFunctionPercentileApproxThreeParams : public AggregateFunctionPercentileApprox {
@@ -337,6 +353,19 @@ class AggregateFunctionPercentileApproxThreeParams : public AggregateFunctionPer
         this->data(place).init(compression.get_element(row_num));
         this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num));
     }
+
+    DataTypePtr get_return_type() const override { return std::make_shared<DataTypeFloat64>(); }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            col.insert_default();
+        } else {
+            col.get_data().push_back(result);
+        }
+    }
 };
 
 template <bool is_nullable>
@@ -390,6 +419,23 @@ class AggregateFunctionPercentileApproxWeightedThreeParams_OLDER
                                               quantile.get_element(row_num));
         }
     }
+
+    DataTypePtr get_return_type() const override {
+        return make_nullable(std::make_shared<DataTypeFloat64>());
+    }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& nullable_column = assert_cast<ColumnNullable&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            nullable_column.insert_default();
+        } else {
+            auto& col = assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
+            col.get_data().push_back(result);
+            nullable_column.get_null_map_data().push_back(0);
+        }
+    }
 };
 
 class AggregateFunctionPercentileApproxWeightedThreeParams
@@ -411,6 +457,19 @@ class AggregateFunctionPercentileApproxWeightedThreeParams
         this->data(place).add_with_weight(sources.get_element(row_num), weight.get_element(row_num),
                                           quantile.get_element(row_num));
     }
+
+    DataTypePtr get_return_type() const override { return std::make_shared<DataTypeFloat64>(); }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            col.insert_default();
+        } else {
+            col.get_data().push_back(result);
+        }
+    }
 };
 
 template <bool is_nullable>
@@ -467,6 +526,23 @@ class AggregateFunctionPercentileApproxWeightedFourParams_OLDER
                                               quantile.get_element(row_num));
         }
     }
+
+    DataTypePtr get_return_type() const override {
+        return make_nullable(std::make_shared<DataTypeFloat64>());
+    }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& nullable_column = assert_cast<ColumnNullable&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            nullable_column.insert_default();
+        } else {
+            auto& col = assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
+            col.get_data().push_back(result);
+            nullable_column.get_null_map_data().push_back(0);
+        }
+    }
 };
 
 class AggregateFunctionPercentileApproxWeightedFourParams
@@ -489,6 +565,19 @@ class AggregateFunctionPercentileApproxWeightedFourParams
         this->data(place).add_with_weight(sources.get_element(row_num), weight.get_element(row_num),
                                           quantile.get_element(row_num));
     }
+
+    DataTypePtr get_return_type() const override { return std::make_shared<DataTypeFloat64>(); }
+
+    void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn& to) const override {
+        auto& col = assert_cast<ColumnFloat64&>(to);
+        double result = AggregateFunctionPercentileApprox::data(place).get();
+
+        if (std::isnan(result)) {
+            col.insert_default();
+        } else {
+            col.get_data().push_back(result);
+        }
+    }
 };
 
 template <typename T>
diff --git a/be/src/vec/aggregate_functions/aggregate_function_stddev.h b/be/src/vec/aggregate_functions/aggregate_function_stddev.h
index 6af310b0ae8fad..5a8c896e1c3247 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_stddev.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_stddev.h
@@ -126,8 +126,6 @@ struct BaseData {
         count += 1;
     }
 
-    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
-
     double mean;
     double m2;
     int64_t count;
@@ -145,6 +143,8 @@ struct PopData : Data {
             col.get_data().push_back(this->get_pop_result());
         }
     }
+
+    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
 };
 
 // For this series of functions, the Decimal type is not supported
@@ -189,6 +189,10 @@ struct SampData_OLDER : Data {
             nullable_column.get_null_map_data().push_back(0);
         }
     }
+
+    static DataTypePtr get_return_type() {
+        return make_nullable(std::make_shared<DataTypeNumber<Float64>>());
+    }
 };
 
 template <typename T, typename Data>
@@ -207,6 +211,8 @@ struct SampData : Data {
             }
         }
     }
+
+    static DataTypePtr get_return_type() { return std::make_shared<DataTypeNumber<Float64>>(); }
 };
 
 template <bool is_pop, typename Data, bool is_nullable>
@@ -221,17 +227,7 @@ class AggregateFunctionSampVariance
 
     String get_name() const override { return Data::name(); }
 
-    DataTypePtr get_return_type() const override {
-        if constexpr (is_pop) {
-            return Data::get_return_type();
-        } else {
-            if (IAggregateFunction::version < AGG_FUNCTION_NULLABLE) {
-                return make_nullable(Data::get_return_type());
-            } else {
-                return Data::get_return_type();
-            }
-        }
-    }
+    DataTypePtr get_return_type() const override { return Data::get_return_type(); }
 
     void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
              Arena*) const override {