[Feature](function) support group concat with distinct and order by

be/src/vec/aggregate_functions/aggregate_function.h

@@ -43,6 +43,8 @@ class AggregateFunctionBitmapCount;
 template <typename Op>
 class AggregateFunctionBitmapOp;
 struct AggregateFunctionBitmapUnionOp;
+class IAggregateFunction;
+using AggregateFunctionPtr = std::shared_ptr<IAggregateFunction>;
 
 using DataTypePtr = std::shared_ptr<const IDataType>;
 using DataTypes = std::vector<DataTypePtr>;
@@ -178,11 +180,6 @@ class IAggregateFunction {
                                         const size_t offset, IColumn& to,
                                         const size_t num_rows) const = 0;
 
-    /** Returns true for aggregate functions of type -State.
-      * They are executed as other aggregate functions, but not finalized (return an aggregation state that can be combined with another).
-      */
-    virtual bool is_state() const { return false; }
-
     /** Contains a loop with calls to "add" function. You can collect arguments into array "places"
       *  and do a single call to "add_batch" for devirtualization and inlining.
       */
@@ -223,6 +220,8 @@ class IAggregateFunction {
 
     virtual void set_version(const int version_) { version = version_; }
 
+    virtual AggregateFunctionPtr transmit_to_stable() { return nullptr; }
+
 protected:
     DataTypes argument_types;
     int version {};
@@ -519,8 +518,6 @@ class IAggregateFunctionDataHelper : public IAggregateFunctionHelper<Derived> {
     }
 };
 
-using AggregateFunctionPtr = std::shared_ptr<IAggregateFunction>;
-
 class AggregateFunctionGuard {
 public:
     using AggregateData = std::remove_pointer_t<AggregateDataPtr>;

be/src/vec/aggregate_functions/aggregate_function_distinct.cpp

@@ -29,6 +29,16 @@
 
 namespace doris::vectorized {
 
+template <typename T>
+struct Reducer {
+    template <bool stable>
+    using Output = AggregateFunctionDistinctSingleNumericData<T, stable>;
+    using AggregateFunctionDistinctNormal = AggregateFunctionDistinct<Output, false>;
+};
+
+template <typename T>
+using AggregateFunctionDistinctNumeric = Reducer<T>::AggregateFunctionDistinctNormal;
+
 class AggregateFunctionCombinatorDistinct final : public IAggregateFunctionCombinator {
 public:
     String get_name() const override { return "Distinct"; }
@@ -52,22 +62,15 @@ class AggregateFunctionCombinatorDistinct final : public IAggregateFunctionCombi
 
         if (arguments.size() == 1) {
             AggregateFunctionPtr res(
-                    creator_with_numeric_type::create<AggregateFunctionDistinct,
-                                                      AggregateFunctionDistinctSingleNumericData>(
+                    creator_with_numeric_type::create<AggregateFunctionDistinctNumeric>(
                             arguments, result_is_nullable, nested_function));
             if (res) {
                 return res;
             }
 
-            if (arguments[0]->is_value_unambiguously_represented_in_contiguous_memory_region()) {
-                res = creator_without_type::create<AggregateFunctionDistinct<
-                        AggregateFunctionDistinctSingleGenericData<true>>>(
-                        arguments, result_is_nullable, nested_function);
-            } else {
-                res = creator_without_type::create<AggregateFunctionDistinct<
-                        AggregateFunctionDistinctSingleGenericData<false>>>(
-                        arguments, result_is_nullable, nested_function);
-            }
+            res = creator_without_type::create<
+                    AggregateFunctionDistinct<AggregateFunctionDistinctSingleGenericData>>(
+                    arguments, result_is_nullable, nested_function);
             return res;
         }
         return creator_without_type::create<