👍

I have not reviewed the code in the datafusion aggregate functions for a while, so I am not familiar with how much they do / don't use the arrow compute kernels, but I think the more we can leverage / reuse those kernels (and their SIMD specializations, if they exist), the better

It might be more idomatic to use let mut rust: Option<i128> = 0; (aka use an Option rather than explicit flag)

Then instead of code like

                    if !has_value && array.is_valid(i) {
                        has_value = true;
                        result = array.value(i);
                    }
                    if array.is_valid(i) {
                        result = result.$OP(array.value(i));
                    }

You could write code like the following (which I think saves at least one check of is_valid()):

                    if array.is_valid(i) {
                        let value = array.value(i);
                        result = result.$OP(result.unwrap_or(value)
                    }

This is just a style suggestion, it is not needed I don't think

I plan to resolve it in the follow-up pull request.
You can merge it if it looks good to you.
@alamb

I recheck your suggestion and find some bugs.
For example, if all value in the array is less than zero, it may be [-1,-3,-3] and we want to get the max value of them.
initially, we set the result as Some(0) and follow your suggestion code, we will get the 0 as the max value for the result.

I think we should just change to that

let mut result = 0_i128; ->>> let mut result : i128 = 0;

In addition the unwrap_or is

    pub fn unwrap_or(self, default: T) -> T {
        match self {
            Some(x) => x,
            None => default,
        }
    }

I think if you added DecimalArray support to arrow::compute::kernels::min and arrow::compute::kernels::max you might be able to use typed_min_max_batch! here. Work for the future perhaps

Yes, when I finish the task of aggregating with decimal data type, I will begin to do basic operations in arrow-rs for decimal data type.

👍