Struct substrait::proto::expression::WindowFunction

pub struct WindowFunction {
    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 partitions: Vec<Expression>,
    pub bounds_type: i32,
    pub lower_bound: Option<Bound>,
    pub upper_bound: Option<Bound>,
    pub args: Vec<Expression>,
}

A window function call.

Fields

function_reference: u32

Points to a function_anchor defined in this plan. The function must be:

• a window function
• an aggregate function

An aggregate function referenced here should be treated as a window function with Window Type STREAMING

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.

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 window function to perform within the context of distributed algorithms. Required. Must be set to INITIAL_TO_RESULT for window functions that are not decomposable.

sorts: Vec<SortField>

If specified, the records that are part of the window defined by upper_bound and lower_bound 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, and is only allowed if the window function is defined to support sorting.

invocation: i32

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

partitions: Vec<Expression>

When one or more partition expressions are specified, two records are considered to be in the same partition if and only if these expressions yield an equal record of values for both. When computing the window function, only the subset of records within the bounds that are also in the same partition as the current record are aggregated.

bounds_type: i32

Defines the bounds type: ROWS, RANGE

lower_bound: Option<Bound>

Defines the record relative to the current record from which the window extends. The bound is inclusive. If the lower bound indexes a record greater than the upper bound, TODO (null range/no records passed? wrapping around as if lower/upper were swapped? error? null?). Optional; defaults to the start of the partition.

upper_bound: Option<Bound>

Defines the record relative to the current record up to which the window extends. The bound is inclusive. If the upper bound indexes a record less than the lower bound, TODO (null range/no records passed? wrapping around as if lower/upper were swapped? error? null?). Optional; defaults to the end of the partition.

args: Vec<Expression>

👎Deprecated

Deprecated; use arguments instead.

Implementations

impl WindowFunction

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.

pub fn bounds_type(&self) -> BoundsType

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

pub fn set_bounds_type(&mut self, value: BoundsType)

Sets bounds_type to the provided enum value.

Trait Implementations

impl Clone for WindowFunction

fn clone(&self) -> WindowFunction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WindowFunction

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

Formats the value using the given formatter.

impl Default for WindowFunction

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for WindowFunction

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for WindowFunction

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<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, 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<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, 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<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

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

where B: Buf, Self: Default,

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

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

where B: Buf, Self: Sized,

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

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

where B: Buf, Self: Sized,

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

impl PartialEq for WindowFunction

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for WindowFunction

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WindowFunction