fix

be/src/vec/aggregate_functions/aggregate_function_bit.cpp

@@ -29,12 +29,6 @@ template <template <typename> class Data>
 AggregateFunctionPtr createAggregateFunctionBitwise(const std::string& name,
                                                     const DataTypes& argument_types,
                                                     const bool result_is_nullable) {
-    if (!argument_types[0]->can_be_used_in_bit_operations()) {
-        LOG(WARNING) << fmt::format("The type " + argument_types[0]->get_name() +
-                                    " of argument for aggregate function " + name +
-                                    " is illegal, because it cannot be used in bitwise operations");
-    }
-
     AggregateFunctionPtr res(creator_with_integer_type::create<AggregateFunctionBitwise, Data>(
             result_is_nullable, argument_types));
     if (res) {

be/src/vec/aggregate_functions/aggregate_function_percentile_approx.cpp

@@ -30,15 +30,15 @@ AggregateFunctionPtr create_aggregate_function_percentile_approx(const std::stri
     if (argument_types.size() == 1) {
         return AggregateFunctionPtr(
                 creator_without_type::create<AggregateFunctionPercentileApproxMerge<is_nullable>>(
-                        result_is_nullable, argument_types));
+                        result_is_nullable, remove_nullable(argument_types)));
     } else if (argument_types.size() == 2) {
         return AggregateFunctionPtr(creator_without_type::create<
                                     AggregateFunctionPercentileApproxTwoParams<is_nullable>>(
-                result_is_nullable, argument_types));
+                result_is_nullable, remove_nullable(argument_types)));
     } else if (argument_types.size() == 3) {
         return AggregateFunctionPtr(creator_without_type::create<
                                     AggregateFunctionPercentileApproxThreeParams<is_nullable>>(
-                result_is_nullable, argument_types));
+                result_is_nullable, remove_nullable(argument_types)));
     }
     LOG(WARNING) << fmt::format("Illegal number {} of argument for aggregate function {}",
                                 argument_types.size(), name);
@@ -48,18 +48,20 @@ AggregateFunctionPtr create_aggregate_function_percentile_approx(const std::stri
 AggregateFunctionPtr create_aggregate_function_percentile(const std::string& name,
                                                           const DataTypes& argument_types,
                                                           const bool result_is_nullable) {
-    return std::make_shared<AggregateFunctionPercentile>(argument_types);
+    return AggregateFunctionPtr(creator_without_type::create<AggregateFunctionPercentile>(
+            result_is_nullable, argument_types));
 }
 
 AggregateFunctionPtr create_aggregate_function_percentile_array(const std::string& name,
                                                                 const DataTypes& argument_types,
                                                                 const bool result_is_nullable) {
-    return std::make_shared<AggregateFunctionPercentileArray>(argument_types);
+    return AggregateFunctionPtr(creator_without_type::create<AggregateFunctionPercentileArray>(
+            result_is_nullable, argument_types));
 }
 
 void register_aggregate_function_percentile(AggregateFunctionSimpleFactory& factory) {
-    factory.register_function("percentile", create_aggregate_function_percentile);
-    factory.register_function("percentile_array", create_aggregate_function_percentile_array);
+    factory.register_function_both("percentile", create_aggregate_function_percentile);
+    factory.register_function_both("percentile_array", create_aggregate_function_percentile_array);
 }
 
 void register_aggregate_function_percentile_approx(AggregateFunctionSimpleFactory& factory) {

be/src/vec/aggregate_functions/aggregate_function_stddev.cpp

@@ -31,19 +31,21 @@ static IAggregateFunction* create_function_single_value(const String& name,
                                                         const bool result_is_nullable) {
     WhichDataType which(remove_nullable(argument_types[0]));
 
-#define DISPATCH(TYPE)                                                                             \
-    if (which.idx == TypeIndex::TYPE)                                                              \
-        return creator_without_type::create<AggregateFunctionTemplate<                             \
-                NameData<Data<TYPE, BaseData<TYPE, is_stddev>>>, is_nullable>>(result_is_nullable, \
-                                                                               argument_types);
+#define DISPATCH(TYPE)                                                          \
+    if (which.idx == TypeIndex::TYPE)                                           \
+        return creator_without_type::create<AggregateFunctionTemplate<          \
+                NameData<Data<TYPE, BaseData<TYPE, is_stddev>>>, is_nullable>>( \
+                result_is_nullable,                                             \
+                is_nullable ? remove_nullable(argument_types) : argument_types);
     FOR_NUMERIC_TYPES(DISPATCH)
 #undef DISPATCH
 
 #define DISPATCH(TYPE)                                                                 \
     if (which.idx == TypeIndex::TYPE)                                                  \
         return creator_without_type::create<AggregateFunctionTemplate<                 \
                 NameData<Data<TYPE, BaseDatadecimal<TYPE, is_stddev>>>, is_nullable>>( \
-                result_is_nullable, argument_types);
+                result_is_nullable,                                                    \
+                is_nullable ? remove_nullable(argument_types) : argument_types);
     FOR_DECIMAL_TYPES(DISPATCH)
 #undef DISPATCH
 
@@ -89,10 +91,10 @@ AggregateFunctionPtr create_aggregate_function_stddev_pop(const std::string& nam
 }
 
 void register_aggregate_function_stddev_variance_pop(AggregateFunctionSimpleFactory& factory) {
-    factory.register_function("variance", create_aggregate_function_variance_pop<false>);
+    factory.register_function_both("variance", create_aggregate_function_variance_pop<false>);
     factory.register_alias("variance", "var_pop");
     factory.register_alias("variance", "variance_pop");
-    factory.register_function("stddev", create_aggregate_function_stddev_pop<true>);
+    factory.register_function_both("stddev", create_aggregate_function_stddev_pop<true>);
     factory.register_alias("stddev", "stddev_pop");
 }
 

be/src/vec/aggregate_functions/aggregate_function_stddev.h

@@ -20,6 +20,7 @@
 #include "common/status.h"
 #include "vec/aggregate_functions/aggregate_function.h"
 #include "vec/columns/columns_number.h"
+#include "vec/common/assert_cast.h"
 #include "vec/data_types/data_type_decimal.h"
 #include "vec/data_types/data_type_nullable.h"
 #include "vec/data_types/data_type_number.h"