use AggregateFunctionPtr if possible

Signed-off-by: Murphy <mofei@starrocks.com>

Author: murphyatwork

be/src/exprs/agg/aggregate.cpp

@@ -353,8 +353,8 @@ template <typename NestedState, IsAggNullPred<NestedState> AggNullPredType>
 AggregateFunctionPtr AggregateFactory::MakeNullableAggregateFunctionVariadic(AggregateFunctionPtr nested_function,
                                                                              AggNullPredType null_pred) {
     using AggregateDataType = NullableAggregateFunctionState<NestedState, false>;
-    return new NullableAggregateFunctionVariadic<AggregateFunctionPtr, AggregateDataType, AggNullPredType>(
-            nested_function, std::move(null_pred));
+    return new NullableAggregateFunctionVariadic<AggregateDataType, AggNullPredType>(nested_function,
+                                                                                     std::move(null_pred));
 }
 
 template <LogicalType LT>

be/src/exprs/agg/factory/aggregate_factory.hpp

@@ -214,16 +214,16 @@ class AggregateFuncResolver {
     }
 
     template <LogicalType ArgLT, LogicalType ResultLT, bool IsNull>
-    const AggregateFunction* create_array_function(std::string& name) {
+    AggregateFunctionPtr create_array_function(std::string& name) {
         if constexpr (IsNull) {
             if (name == "dict_merge") {
                 auto dict_merge = track_function(AggregateFactory::MakeDictMergeAggregateFunction());
                 return track_function(
                         AggregateFactory::MakeNullableAggregateFunctionUnary<DictMergeState, false>(dict_merge));
             } else if (name == "retention") {
-                auto retentoin = track_function(AggregateFactory::MakeRetentionAggregateFunction());
+                auto retention = track_function(AggregateFactory::MakeRetentionAggregateFunction());
                 return track_function(
-                        AggregateFactory::MakeNullableAggregateFunctionUnary<RetentionState, false>(retentoin));
+                        AggregateFactory::MakeNullableAggregateFunctionUnary<RetentionState, false>(retention));
             } else if (name == "window_funnel") {
                 if constexpr (ArgLT == TYPE_INT || ArgLT == TYPE_BIGINT || ArgLT == TYPE_DATE ||
                               ArgLT == TYPE_DATETIME) {
@@ -250,7 +250,7 @@ class AggregateFuncResolver {
     }
 
     template <LogicalType ArgLT, LogicalType ResultLT, bool IsWindowFunc, bool IsNull>
-    std::enable_if_t<isArithmeticLT<ArgLT>, const AggregateFunction*> create_decimal_function(std::string& name) {
+    std::enable_if_t<isArithmeticLT<ArgLT>, AggregateFunctionPtr> create_decimal_function(std::string& name) {
         static_assert(lt_is_decimal128<ResultLT> || lt_is_decimal256<ResultLT>);
         if constexpr (IsNull) {
             using ResultType = RunTimeCppType<ResultLT>;

be/src/exprs/agg/factory/aggregate_resolver.hpp

@@ -15,6 +15,7 @@
 #pragma once
 
 #include "column/column.h"
+#include "exprs/agg/aggregate.h"
 #ifdef __x86_64__
 #include <immintrin.h>
 #elif defined(__ARM_NEON) && defined(__aarch64__)
@@ -108,7 +109,7 @@ struct AggNonNullPred {
 //    For this case, the serialized output type is non-nullable, because only the state of input needs to be serialized.
 // If all the rows are NULL or `AggNullPred` returns true, we will return NULL.
 // The State must be NullableAggregateFunctionState
-template <typename NestedFuncPtr, typename State, bool IsWindowFunc, bool IgnoreNull = true,
+template <typename NestedAggregateFunctionPtr, typename State, bool IsWindowFunc, bool IgnoreNull = true,
           IsAggNullPred<typename State::NestedState> AggNullPred = AggNonNullPred<typename State::NestedState>>
 class NullableAggregateFunctionBase : public AggregateFunctionStateHelper<State> {
     using NestedState = typename State::NestedState;
@@ -117,7 +118,8 @@ class NullableAggregateFunctionBase : public AggregateFunctionStateHelper<State>
 public:
     bool is_exception_safe() const override { return nested_function->is_exception_safe(); }
 
-    explicit NullableAggregateFunctionBase(NestedFuncPtr nested_function_, AggNullPred null_pred = AggNullPred())
+    explicit NullableAggregateFunctionBase(NestedAggregateFunctionPtr nested_function_,
+                                           AggNullPred null_pred = AggNullPred())
             : nested_function(std::move(nested_function_)), null_pred(std::move(null_pred)) {}
     // as array_agg is not nullable, so it needn't create() here.
 
@@ -311,17 +313,19 @@ class NullableAggregateFunctionBase : public AggregateFunctionStateHelper<State>
     }
 
 protected:
-    NestedFuncPtr nested_function;
+    NestedAggregateFunctionPtr nested_function;
     AggNullPred null_pred;
 };
 
-template <typename NestedFuncPtr, typename State, bool IsWindowFunc, bool IgnoreNull = true,
+template <typename NestedAggregateFunctionPtr, typename State, bool IsWindowFunc, bool IgnoreNull = true,
           IsAggNullPred<typename State::NestedState> AggNullPred = AggNonNullPred<typename State::NestedState>>
 class NullableAggregateFunctionUnary final
-        : public NullableAggregateFunctionBase<NestedFuncPtr, State, IsWindowFunc, IgnoreNull, AggNullPred> {
+        : public NullableAggregateFunctionBase<NestedAggregateFunctionPtr, State, IsWindowFunc, IgnoreNull,
+                                               AggNullPred> {
 public:
-    explicit NullableAggregateFunctionUnary(const NestedFuncPtr& nested_function, AggNullPred null_pred = AggNullPred())
-            : NullableAggregateFunctionBase<NestedFuncPtr, State, IsWindowFunc, IgnoreNull, AggNullPred>(
+    explicit NullableAggregateFunctionUnary(const NestedAggregateFunctionPtr& nested_function,
+                                            AggNullPred null_pred = AggNullPred())
+            : NullableAggregateFunctionBase<NestedAggregateFunctionPtr, State, IsWindowFunc, IgnoreNull, AggNullPred>(
                       nested_function, std::move(null_pred)) {}
 
     // NOTE: In stream MV, need handle input row by row, so need support single update.
@@ -948,14 +952,15 @@ class NullableAggregateFunctionUnary final
     }
 };
 
-template <typename NestedFuncPtr, typename State,
+template <typename State,
           IsAggNullPred<typename State::NestedState> AggNullPredType = AggNonNullPred<typename State::NestedState>>
 class NullableAggregateFunctionVariadic final
-        : public NullableAggregateFunctionBase<NestedFuncPtr, State, false, true, AggNullPredType> {
+        : public NullableAggregateFunctionBase<AggregateFunctionPtr, State, false, true, AggNullPredType> {
 public:
-    NullableAggregateFunctionVariadic(NestedFuncPtr nested_function, AggNullPredType null_pred = AggNullPredType())
-            : NullableAggregateFunctionBase<NestedFuncPtr, State, false, true, AggNullPredType>(
-                      std::move(nested_function), std::move(null_pred)) {}
+    NullableAggregateFunctionVariadic(AggregateFunctionPtr nested_function,
+                                      AggNullPredType null_pred = AggNullPredType())
+            : NullableAggregateFunctionBase<AggregateFunctionPtr, State, false, true, AggNullPredType>(
+                      nested_function, std::move(null_pred)) {}
 
     void update(FunctionContext* ctx, const Column** columns, AggDataPtr __restrict state,
                 size_t row_num) const override {