Enum mz_sql::plan::expr::AggregateFunc

pub enum AggregateFunc {
    MaxNumeric,
    MaxInt16,
    MaxInt32,
    MaxInt64,
    MaxUInt16,
    MaxUInt32,
    MaxUInt64,
    MaxMzTimestamp,
    MaxFloat32,
    MaxFloat64,
    MaxBool,
    MaxString,
    MaxDate,
    MaxTimestamp,
    MaxTimestampTz,
    MaxInterval,
    MaxTime,
    MinNumeric,
    MinInt16,
    MinInt32,
    MinInt64,
    MinUInt16,
    MinUInt32,
    MinUInt64,
    MinMzTimestamp,
    MinFloat32,
    MinFloat64,
    MinBool,
    MinString,
    MinDate,
    MinTimestamp,
    MinTimestampTz,
    MinInterval,
    MinTime,
    SumInt16,
    SumInt32,
    SumInt64,
    SumUInt16,
    SumUInt32,
    SumUInt64,
    SumFloat32,
    SumFloat64,
    SumNumeric,
    Count,
    Any,
    All,
    JsonbAgg {
        order_by: Vec<ColumnOrder>,
    },
    JsonbObjectAgg {
        order_by: Vec<ColumnOrder>,
    },
    MapAgg {
        order_by: Vec<ColumnOrder>,
        value_type: ScalarType,
    },
    ArrayConcat {
        order_by: Vec<ColumnOrder>,
    },
    ListConcat {
        order_by: Vec<ColumnOrder>,
    },
    StringAgg {
        order_by: Vec<ColumnOrder>,
    },
    Dummy,
}

Aggregate functions analogous to mz_expr::AggregateFunc, but whose types may be different.

Specifically, the nullability of the aggregate columns is more common here than in expr, as these aggregates may be applied over empty result sets and should be null in those cases, whereas expr variants only return null values when supplied nulls as input.

Variants

MaxNumeric

MaxInt16

MaxInt32

MaxInt64

MaxUInt16

MaxUInt32

MaxUInt64

MaxMzTimestamp

MaxFloat32

MaxFloat64

MaxBool

MaxString

MaxDate

MaxTimestamp

MaxTimestampTz

MaxInterval

MaxTime

MinNumeric

MinInt16

MinInt32

MinInt64

MinUInt16

MinUInt32

MinUInt64

MinMzTimestamp

MinFloat32

MinFloat64

MinBool

MinString

MinDate

MinTimestamp

MinTimestampTz

MinInterval

MinTime

SumInt16

SumInt32

SumInt64

SumUInt16

SumUInt32

SumUInt64

SumFloat32

SumFloat64

SumNumeric

Count

Any

All

JsonbAgg

Accumulates Datum::Lists whose first element is a JSON-typed Datums into a JSON list. The other elements are columns used by order_by.

WARNING: Unlike the jsonb_agg function that is exposed by the SQL layer, this function filters out Datum::Null, for consistency with the other aggregate functions.

Fields

order_by: Vec<ColumnOrder>

JsonbObjectAgg

Zips Datum::Lists whose first element is a JSON-typed Datums into a JSON map. The other elements are columns used by order_by.

Fields

order_by: Vec<ColumnOrder>

MapAgg

Zips a Datum::List whose first element is a Datum::List guaranteed to be non-empty and whose len % 2 == 0 into a Datum::Map. The other elements are columns used by order_by.

Fields

order_by: Vec<ColumnOrder>

value_type: ScalarType

ArrayConcat

Accumulates Datum::Lists whose first element is a Datum::Array into a single Datum::Array. The other elements are columns used by order_by.

Fields

order_by: Vec<ColumnOrder>

ListConcat

Accumulates Datum::Lists whose first element is a Datum::List into a single Datum::List. The other elements are columns used by order_by.

Fields

order_by: Vec<ColumnOrder>

StringAgg

Fields

order_by: Vec<ColumnOrder>

Dummy

Accumulates any number of Datum::Dummys into Datum::Dummy.

Useful for removing an expensive aggregation while maintaining the shape of a reduce operator.

Implementations

impl AggregateFunc

pub fn into_expr(self) -> AggregateFunc

Converts the sql::AggregateFunc to a corresponding mz_expr::AggregateFunc.

pub fn identity_datum(&self) -> Datum<'static>

Returns a datum whose inclusion in the aggregation will not change its result.

pub fn output_type(&self, input_type: ColumnType) -> ColumnType

The output column type for the result of an aggregation.

The output column type also contains nullability information, which is (without further information) true for aggregations that are not counts.

pub fn is_order_sensitive(&self) -> bool

Trait Implementations

impl Clone for AggregateFunc

fn clone(&self) -> AggregateFunc

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AggregateFunc

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AggregateFunc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AggregateFunc> for Operation<(HirScalarExpr, AggregateFunc)>

fn from(a: AggregateFunc) -> Operation<(HirScalarExpr, AggregateFunc)>

Converts to this type from the input type.

impl Hash for AggregateFunc

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AggregateFunc

fn cmp(&self, other: &AggregateFunc) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for AggregateFunc

fn eq(&self, other: &AggregateFunc) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for AggregateFunc

fn partial_cmp(&self, other: &AggregateFunc) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for AggregateFunc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AggregateFunc

impl StructuralPartialEq for AggregateFunc