Struct AggregateFunction 

pub struct AggregateFunction {
    pub function_reference: u32,
    pub arguments: Vec<FunctionArgument>,
    pub options: Vec<FunctionOption>,
    pub output_type: Option<Type>,
    pub phase: i32,
    pub sorts: Vec<SortField>,
    pub invocation: i32,
    pub args: Vec<Expression>,
}

An aggregate function.

Fields

function_reference: u32

Points to a function_anchor defined in this plan, which must refer to an aggregate function in the associated YAML file. Required; 0 is considered to be a valid anchor/reference.

arguments: Vec<FunctionArgument>

The arguments to be bound to the function. This must have exactly the number of arguments specified in the function definition, and the argument types must also match exactly:

• Value arguments must be bound using FunctionArgument.value, and the expression in that must yield a value of a type that a function overload is defined for.
• Type arguments must be bound using FunctionArgument.type, and a function overload must be defined for that type.
• Enum arguments must be bound using FunctionArgument.enum followed by Enum.specified, with a string that case-insensitively matches one of the allowed options.
• Optional enum arguments must be bound using FunctionArgument.enum followed by either Enum.specified or Enum.unspecified. If specified, the string must case-insensitively match one of the allowed options.

options: Vec<FunctionOption>

Options to specify behavior for corner cases, or leave behavior unspecified if the consumer does not need specific behavior in these cases.

output_type: Option<Type>

Must be set to the return type of the function, exactly as derived using the declaration in the extension.

phase: i32

Describes which part of the aggregation to perform within the context of distributed algorithms. Required. Must be set to INITIAL_TO_RESULT for aggregate functions that are not decomposable.

sorts: Vec<SortField>

If specified, the aggregated records are ordered according to this list before they are aggregated. The first sort field has the highest priority; only if a sort field determines two records to be equivalent is the next field queried. This field is optional.

invocation: i32

Specifies whether equivalent records are merged before being aggregated. Optional, defaults to AGGREGATION_INVOCATION_ALL.

args: Vec<Expression>

👎Deprecated

deprecated; use arguments instead

Implementations

impl AggregateFunction

pub fn phase(&self) -> AggregationPhase

Returns the enum value of phase, or the default if the field is set to an invalid enum value.

pub fn set_phase(&mut self, value: AggregationPhase)

Sets phase to the provided enum value.

pub fn invocation(&self) -> AggregationInvocation

Returns the enum value of invocation, or the default if the field is set to an invalid enum value.

pub fn set_invocation(&mut self, value: AggregationInvocation)

Sets invocation to the provided enum value.

Trait Implementations

impl Clone for AggregateFunction

fn clone(&self) -> AggregateFunction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateFunction

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

Formats the value using the given formatter.

impl Default for AggregateFunction

fn default() -> Self

Returns the “default value” for a type.

impl InputNode for AggregateFunction

fn type_to_node() -> Node

Creates an empty output node for a protobuf datum of this type.

fn data_to_node(&self) -> Node

Creates an empty output node for a protobuf datum with this value.

fn oneof_variant(&self) -> Option<&'static str>

Returns the name of the selected variant of a oneof field, if this is a rust enum used to represent a oneof field.

fn parse_unknown(&self, y: &mut Context<'_>) -> bool

Complete the subtrees of this datum in output that have not already been parsed using UnknownField nodes. Returns whether any such nodes were added.

impl Message for AggregateFunction

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for AggregateFunction

fn eq(&self, other: &AggregateFunction) -> 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 ProtoMessage for AggregateFunction

fn proto_message_type() -> &'static str

Returns the protobuf type name for messages of this type.

impl StructuralPartialEq for AggregateFunction