Support argMax/argMin

[tlightsky]

Summary
pretty useful aggregate function

Example

Input table:

┌─user─────┬─salary─┐
│ director │   5000 │
│ manager  │   3000 │
│ worker   │   1000 │
└──────────┴────────┘

Query:

SELECT argMax(user, salary) FROM salary;

Result:

┌─argMax(user, salary)─┐
│ director             │
└──────────────────────┘

Query:

SELECT argMin(user, salary) FROM salary;

Result:

┌─argMax(user, salary)─┐
│ worker               │
└──────────────────────┘

argMax
argMin

[JmPotato]

I'd like to take this task😄.

[JmPotato]

@tlightsky @BohuTANG It seems that the logic of argMax/argMin is very similar to the aggregation function Max/Min. One thing different is that we need to track the max value's corresponding arg column. It seems that recording the index of the max value while doing data_array_aggregate_op is a rather simple idea to implement. Could you please give me some advice or instructions on this? Thx!

[sundy-li]

It's ok to implement a simple version without SIMD.

We can keep a state in AggregateArgMaxFunction to store the max state of the tuple (c, score)

In the accumulate method, we iterate the columns to update the state.

fn accumulate(&mut self, columns: &[DataColumnarValue], input_rows: usize) -> Result<()> {

It may be better to make it support Template states, but currently, there is no templated aggregate function in datafuse.
See also: https://github.com/ClickHouse/ClickHouse/blob/master/src/AggregateFunctions/AggregateFunctionMinMaxAny.h

[JmPotato]

It's ok to implement a simple version without SIMD.

We can keep a state in AggregateArgMaxFunction to store the max state of the tuple (c, score)

In the accumulate method, we iterate the columns to update the state.

fn accumulate(&mut self, columns: &[DataColumnarValue], input_rows: usize) -> Result<()> {

It may be better to make it support Template states, but currently, there is no templated aggregate function in datafuse.
See also: https://github.com/ClickHouse/ClickHouse/blob/master/src/AggregateFunctions/AggregateFunctionMinMaxAny.h

Yeah, this method is quite straightforward, but after checking the code, I have a question.

If we want to iterate the columns in the accumulate method, the very first beginning of the process is to downcast the ArrayRef to a specified typed Array. And because the input of argMax/argMin will have two columns, does it means that I have to list all combinations of types just like data_value_arithmetic_op? Is there a better way to do this?

Of course, if I’m wrong, please point it out. Thx!

[sundy-li]

If we want to iterate the columns in the accumulate method, the very first beginning of the process is to downcast the ArrayRef to a specified typed Array

@JmPotato You are right.

argMax( col_a, col_score)

1. There are 2 two columns, but we don't need to cast column col_a, because we have a function DataValue::try_from_array(array, row) to get the DataValue by row index.

2. For column col_score, we can use match to cast it to PrimitiveArray, and then we can get the data as natvie array, such as: let data: &[T::Native] = array.values();

I think with these two points, you can finish a simple version of argMax AggregateFunction .

PS: Currently IAggregateFunction is in early stage, I think it's better to create generic AggregateFunction from Factory:

 pub fn try_create(display_name: &str, arg_types: &[DataType]) -> Result<Box<dyn IAggregateFunction>> {
    
        match arg_types[0] {
             DataTypeUInt64 ==>    AggregateMaxFunction< Data<Int64Type::Native> >
        }))
        } 
      
    }

It needs some not easy changes, If you are interested, it should be great to move on.

[JmPotato]

If we want to iterate the columns in the accumulate method, the very first beginning of the process is to downcast the ArrayRef to a specified typed Array

@JmPotato You are right.

argMax( col_a, col_score)

1. There are 2 two columns, but we don't need to cast column col_a, because we have a function DataValue::try_from_array(array, row) to get the DataValue by row index.
2. For column col_score, we can use match to cast it to PrimitiveArray, and then we can get the data as natvie array, such as: let data: &[T::Native] = array.values();

I think with these two points, you can finish a simple version of argMax AggregateFunction .

PS: Currently IAggregateFunction is in early stage, I think it's better to create generic AggregateFunction from Factory:

 pub fn try_create(display_name: &str, arg_types: &[DataType]) -> Result<Box<dyn IAggregateFunction>> {
    
        match arg_types[0] {
             DataTypeUInt64 ==>    AggregateMaxFunction< Data<Int64Type::Native> >
        }))
        } 
      
    }

It needs some not easy changes, If you are interested, it should be great to move on.

PR #642 is proposed to implement these two functions first, and I think we could open another issue to track the refactoring work later.