fix

Author: b41sh

src/query/functions/src/scalars/array.rs

@@ -22,7 +22,6 @@ use common_expression::types::nullable::NullableDomain;
 use common_expression::types::number::NumberScalar;
 use common_expression::types::number::SimpleDomain;
 use common_expression::types::number::UInt64Type;
-use common_expression::types::AnyType;
 use common_expression::types::ArgType;
 use common_expression::types::ArrayType;
 use common_expression::types::BooleanType;
@@ -47,7 +46,6 @@ use common_expression::with_number_mapped_type;
 use common_expression::Column;
 use common_expression::ColumnBuilder;
 use common_expression::Domain;
-use common_expression::EvalContext;
 use common_expression::Function;
 use common_expression::FunctionDomain;
 use common_expression::FunctionProperty;
@@ -644,68 +642,61 @@ fn register_array_aggr(registry: &mut FunctionRegistry) {
         Some(return_type)
     }
 
-    fn eval_array_aggr(
-        name: &str,
-        args: &[ValueRef<AnyType>],
-        ctx: &mut EvalContext,
-    ) -> Value<AnyType> {
-        match &args[0] {
-            ValueRef::Scalar(scalar) => match scalar {
-                ScalarRef::EmptyArray | ScalarRef::Null => {
-                    if name == "count" {
-                        Value::Scalar(Scalar::Number(NumberScalar::UInt64(0)))
-                    } else {
-                        Value::Scalar(Scalar::Null)
-                    }
-                }
-                ScalarRef::Array(col) => {
-                    let len = col.len();
-                    match eval_aggr(name, vec![], &[col.clone()], len) {
-                        Ok((res_col, _)) => {
-                            let val = unsafe { res_col.index_unchecked(0) };
-                            Value::Scalar(val.to_owned())
-                        }
-                        Err(err) => {
-                            ctx.set_error(0, err.to_string());
-                            Value::Scalar(Scalar::Null)
-                        }
-                    }
-                }
-                _ => unreachable!(),
-            },
-            ValueRef::Column(column) => {
-                let return_type = eval_aggr_return_type(name, &[column.data_type()]).unwrap();
-                let mut builder = ColumnBuilder::with_capacity(&return_type, column.len());
-                for arr in column.iter() {
-                    let array_column = arr.as_array().unwrap();
-                    let len = array_column.len();
-                    match eval_aggr(name, vec![], &[array_column.clone()], len) {
-                        Ok((col, _)) => {
-                            let val = unsafe { col.index_unchecked(0) };
-                            builder.push(val)
-                        }
-                        Err(err) => {
-                            ctx.set_error(builder.len(), err.to_string());
-                        }
-                    }
-                }
-                Value::Column(builder.build())
-            }
-        }
-    }
-
-    for (func_name, name) in ARRAY_AGGREGATE_FUNCTIONS {
-        registry.register_function_factory(func_name, |_, args_type| {
+    for (fn_name, name) in ARRAY_AGGREGATE_FUNCTIONS {
+        registry.register_function_factory(fn_name, |_, args_type| {
             let return_type = eval_aggr_return_type(name, args_type)?;
             Some(Arc::new(Function {
                 signature: FunctionSignature {
-                    name: func_name.to_string(),
+                    name: fn_name.to_string(),
                     args_type: vec![args_type[0].clone()],
                     return_type,
                     property: FunctionProperty::default(),
                 },
                 calc_domain: Box::new(move |_| FunctionDomain::MayThrow),
-                eval: Box::new(|args, ctx| eval_array_aggr(name, args, ctx)),
+                eval: Box::new(|args, ctx| match &args[0] {
+                    ValueRef::Scalar(scalar) => match scalar {
+                        ScalarRef::EmptyArray | ScalarRef::Null => {
+                            if name == "count" {
+                                Value::Scalar(Scalar::Number(NumberScalar::UInt64(0)))
+                            } else {
+                                Value::Scalar(Scalar::Null)
+                            }
+                        }
+                        ScalarRef::Array(col) => {
+                            let len = col.len();
+                            match eval_aggr(name, vec![], &[col.clone()], len) {
+                                Ok((res_col, _)) => {
+                                    let val = unsafe { res_col.index_unchecked(0) };
+                                    Value::Scalar(val.to_owned())
+                                }
+                                Err(err) => {
+                                    ctx.set_error(0, err.to_string());
+                                    Value::Scalar(Scalar::Null)
+                                }
+                            }
+                        }
+                        _ => unreachable!(),
+                    },
+                    ValueRef::Column(column) => {
+                        let return_type =
+                            eval_aggr_return_type(name, &[column.data_type()]).unwrap();
+                        let mut builder = ColumnBuilder::with_capacity(&return_type, column.len());
+                        for arr in column.iter() {
+                            let array_column = arr.as_array().unwrap();
+                            let len = array_column.len();
+                            match eval_aggr(name, vec![], &[array_column.clone()], len) {
+                                Ok((col, _)) => {
+                                    let val = unsafe { col.index_unchecked(0) };
+                                    builder.push(val)
+                                }
+                                Err(err) => {
+                                    ctx.set_error(builder.len(), err.to_string());
+                                }
+                            }
+                        }
+                        Value::Column(builder.build())
+                    }
+                }),
             }))
         });
     }