[refine](function) enforce final on CRTP aggregate function derived classes to enable compiler devirtualization (#62433)

`IAggregateFunctionHelper<Derived>` implements hot aggregate paths such
as `add_batch()` and `add_batch_single_place()` by calling
`assert_cast<const Derived*>(this)->add(...)`. Because `add()` is
declared `virtual` in `IAggregateFunction`, the compiler cannot
devirtualize this call unless it can prove that `Derived` has no further
overrides — which requires `Derived` to be marked `final`.

This PR enforces this via a `static_assert` in the
`IAggregateFunctionHelper` constructor. Note that `final` here is a
**performance hint only** — correctness is not affected, since `add()`
remains virtual and subclasses always dispatch correctly through the
vtable regardless. Marking `Derived` as `final` allows the compiler to
devirtualize (and potentially inline) the `add()` call inside hot
aggregation paths.

Changes:

1. Add a `static_assert` in the `IAggregateFunctionHelper` constructor
asserting `std::is_final_v<Derived>`, so that missing `final` is caught
at compile time.
2. Introduce `AggregateFunctionNonFinalBase` as an opt-out marker for
classes that intentionally form inheritance hierarchies (e.g.
`AggregateStateUnion → AggregateStateMerge`, `AggregateFunctionForEach →
AggregateFunctionForEachV2`).
3. Mark all concrete aggregate function classes `final` across
`be/src/exprs/aggregate/`.
4. Refactor `AggregateFunctionTopNBase` to accept a `Derived` template
parameter so that `AggregateFunctionTopN` and
`AggregateFunctionTopNArray` can each be marked `final`.
5. Refactor `AggregateFunctionPercentileApprox` into
`AggregateFunctionPercentileApproxBase<Derived>` so the four concrete
specializations can each be marked `final`.

Author: Mryange

be/src/exprs/aggregate/aggregate_function.h

@@ -303,12 +303,42 @@ class IAggregateFunction {
     int version {};
 };
 
+/// Marker base for aggregate function classes that intentionally form an inheritance
+/// hierarchy (e.g. AggregateStateUnion -> AggregateStateMerge, or
+/// AggregateFunctionForEach -> AggregateFunctionForEachV2) and therefore cannot be
+/// marked 'final'. Classes that inherit this marker are exempt from the
+/// static_assert in IAggregateFunctionHelper.
+struct AggregateFunctionNonFinalBase {};
+
 /// Implement method to obtain an address of 'add' function.
 template <typename Derived>
 class IAggregateFunctionHelper : public IAggregateFunction {
 public:
     IAggregateFunctionHelper(const DataTypes& argument_types_)
-            : IAggregateFunction(argument_types_) {}
+            : IAggregateFunction(argument_types_) {
+        // NOTE: This static_assert is placed in the constructor body (not at class scope)
+        // because at class-scope instantiation time Derived is still an incomplete type,
+        // whereas the constructor body is instantiated lazily when a concrete object is
+        // constructed, at which point Derived is fully defined.
+        //
+        // Marking Derived as 'final' is an *optimization hint*, not a correctness
+        // requirement. add() is virtual in IAggregateFunction, so subclasses always
+        // dispatch correctly through the vtable regardless. However, when Derived is
+        // final, the compiler can see that assert_cast<const Derived*>(this)->add(...)
+        // inside add_batch() / add_batch_single_place() etc. has no further overrides,
+        // allowing it to devirtualize (and potentially inline) the add() call -- which
+        // is critical for hot aggregation paths.
+        //
+        // Classes that intentionally form inheritance hierarchies (and therefore accept
+        // the vtable overhead) must inherit AggregateFunctionNonFinalBase to opt out.
+        static_assert(
+                std::is_final_v<Derived> ||
+                        std::is_base_of_v<AggregateFunctionNonFinalBase, Derived>,
+                "Derived should be marked 'final' to allow the compiler to devirtualize "
+                "add() calls inside add_batch() and related hot paths. "
+                "If the class intentionally has subclasses, inherit AggregateFunctionNonFinalBase "
+                "to opt out of this check.");
+    }
 
     void destroy_vec(AggregateDataPtr __restrict place,
                      const size_t num_rows) const noexcept override {

be/src/exprs/aggregate/aggregate_function_array_agg.h

@@ -277,7 +277,7 @@ struct AggregateFunctionArrayAggData<T> {
 //ShowNull is just used to support array_agg because array_agg needs to display NULL
 //todo: Supports order by sorting for array_agg
 template <typename Data>
-class AggregateFunctionArrayAgg
+class AggregateFunctionArrayAgg final
         : public IAggregateFunctionDataHelper<Data, AggregateFunctionArrayAgg<Data>, true>,
           UnaryExpression,
           NotNullableAggregateFunction {

be/src/exprs/aggregate/aggregate_function_binary.h

@@ -41,7 +41,7 @@ struct StatFunc {
 };
 
 template <typename StatFunc>
-struct AggregateFunctionBinary
+struct AggregateFunctionBinary final
         : public IAggregateFunctionDataHelper<typename StatFunc::Data,
                                               AggregateFunctionBinary<StatFunc>>,
           MultiExpression,

be/src/exprs/aggregate/aggregate_function_collect.h

@@ -392,7 +392,7 @@ struct AggregateFunctionCollectListData<T, HasLimit> {
 };
 
 template <typename Data, bool HasLimit>
-class AggregateFunctionCollect
+class AggregateFunctionCollect final
         : public IAggregateFunctionDataHelper<Data, AggregateFunctionCollect<Data, HasLimit>, true>,
           VarargsExpression,
           NotNullableAggregateFunction {

be/src/exprs/aggregate/aggregate_function_covar.h

@@ -137,7 +137,7 @@ struct SampData : BaseData<T> {
 };
 
 template <typename Data>
-class AggregateFunctionSampCovariance
+class AggregateFunctionSampCovariance final
         : public IAggregateFunctionDataHelper<Data, AggregateFunctionSampCovariance<Data>>,
           MultiExpression,
           NullableAggregateFunction {

be/src/exprs/aggregate/aggregate_function_distinct.h

@@ -260,7 +260,7 @@ struct AggregateFunctionDistinctMultipleGenericData
   * Adding -Distinct suffix to aggregate function
 **/
 template <template <bool stable> typename Data, bool stable = false>
-class AggregateFunctionDistinct
+class AggregateFunctionDistinct final
         : public IAggregateFunctionDataHelper<Data<stable>,
                                               AggregateFunctionDistinct<Data, stable>>,
           VarargsExpression,

be/src/exprs/aggregate/aggregate_function_foreach.h

@@ -51,7 +51,8 @@ struct AggregateFunctionForEachData {
   *
   * TODO Allow variable number of arguments.
   */
-class AggregateFunctionForEach : public IAggregateFunctionDataHelper<AggregateFunctionForEachData,
+class AggregateFunctionForEach : public AggregateFunctionNonFinalBase,
+                                 public IAggregateFunctionDataHelper<AggregateFunctionForEachData,
                                                                      AggregateFunctionForEach>,
                                  VarargsExpression,
                                  NullableAggregateFunction {

be/src/exprs/aggregate/aggregate_function_foreachv2.cpp

@@ -35,7 +35,7 @@ namespace doris {
 // because we may have already assumed that the array's elements are always nullable types, and many places have such checks.
 // V1 code is kept to ensure compatibility during upgrades and downgrades.
 // V2 code differs from V1 only in the return type and insert_into logic; all other logic is exactly the same.
-class AggregateFunctionForEachV2 : public AggregateFunctionForEach {
+class AggregateFunctionForEachV2 final : public AggregateFunctionForEach {
 public:
     constexpr static auto AGG_FOREACH_SUFFIX = "_foreachv2";
     AggregateFunctionForEachV2(AggregateFunctionPtr nested_function_, const DataTypes& arguments)

be/src/exprs/aggregate/aggregate_function_group_array_set_op.h

@@ -405,7 +405,7 @@ struct GroupArrayStringUnionData : public GroupArraySetOpStringBaseData {
 
 /// Puts all values to the hybrid set. Returns an array of unique values
 template <typename ImplData>
-class AggregateFunctionGroupArraySetOp
+class AggregateFunctionGroupArraySetOp final
         : public IAggregateFunctionDataHelper<ImplData, AggregateFunctionGroupArraySetOp<ImplData>>,
           UnaryExpression,
           NotNullableAggregateFunction {

be/src/exprs/aggregate/aggregate_function_hll_union_agg.h

@@ -100,7 +100,7 @@ struct AggregateFunctionHLLUnionAggImpl : Data {
 };
 
 template <typename Data>
-class AggregateFunctionHLLUnion
+class AggregateFunctionHLLUnion final
         : public IAggregateFunctionDataHelper<Data, AggregateFunctionHLLUnion<Data>>,
           UnaryExpression,
           NullableAggregateFunction {