Struct Mode 

struct Mode {
    return_type: DataType,
}

Computes the mode, the most frequent value of the aggregated argument (arbitrarily choosing the first one if there are multiple equally-frequent values). The aggregated argument must be of a sortable type.

query I
select mode() within group (order by unnest) from unnest(array[1]);
----
1

query I
select mode() within group (order by unnest) from unnest(array[1,2,2,3,3,4,4,4]);
----
4

query R
select mode() within group (order by unnest) from unnest(array[0.1,0.2,0.2,0.4,0.4,0.3,0.3,0.4]);
----
0.4

query R
select mode() within group (order by unnest) from unnest(array[1,2,2,3,3,4,4,4,3]);
----
3

query T
select mode() within group (order by unnest) from unnest(array['1','2','2','3','3','4','4','4','3']);
----
3

query I
select mode() within group (order by unnest) from unnest(array[]::int[]);
----
NULL

Fields

return_type: DataType

Trait Implementations

impl AggregateFunction for Mode

fn return_type(&self) -> DataType

Returns the return type of the aggregate function.

fn create_state(&self) -> Result<AggregateState>

Creates an initial state of the aggregate function.

fn update<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 mut AggregateState, input: &'life2 StreamChunk, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update the state with multiple rows.

fn update_range<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 mut AggregateState, input: &'life2 StreamChunk, range: Range<usize>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update the state with a range of rows.

fn get_result<'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 AggregateState, ) -> Pin<Box<dyn Future<Output = Result<Datum>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get aggregate result from the state.

fn encode_state( &self, state: &AggregateState, ) -> Result<Option<ScalarImpl>, ExprError>

Encode the state into a datum that can be stored in state table.

fn decode_state( &self, datum: Option<ScalarImpl>, ) -> Result<AggregateState, ExprError>

Decode the state from a datum in state table.