Struct postgres_parser::nodes::Aggref

pub struct Aggref {
    pub aggfnoid: Oid,
    pub aggtype: Oid,
    pub aggcollid: Oid,
    pub inputcollid: Oid,
    pub aggtranstype: Oid,
    pub aggargtypes: Option<Vec<Node>>,
    pub aggdirectargs: Option<Vec<Node>>,
    pub args: Option<Vec<Node>>,
    pub aggorder: Option<Vec<Node>>,
    pub aggdistinct: Option<Vec<Node>>,
    pub aggfilter: Option<Box<Expr>>,
    pub aggstar: bool,
    pub aggvariadic: bool,
    pub aggkind: char,
    pub agglevelsup: Index,
    pub aggsplit: AggSplit,
    pub location: i32,
}

Aggref

The aggregate's args list is a targetlist, ie, a list of TargetEntry nodes.

For a normal (nonorderedset) aggregate, the nonresjunk TargetEntries represent the aggregate's regular arguments (if any) and resjunk TLEs can be added at the end to represent ORDER BY expressions that are not also arguments. As in a toplevel Query, the TLEs can be marked with ressortgroupref indexes to let them be referenced by SortGroupClause entries in the aggorder and/or aggdistinct lists. This represents ORDER BY and DISTINCT operations to be applied to the aggregate input rows before they are passed to the transition function. The grammar only allows a simple "DISTINCT" specifier for the arguments, but we use the full querylevel representation to allow more code sharing.

For an orderedset aggregate, the args list represents the WITHIN GROUP (aggregated) arguments, all of which will be listed in the aggorder list. DISTINCT is not supported in this case, so aggdistinct will be NIL. The direct arguments appear in aggdirectargs (as a list of plain expressions, not TargetEntry nodes).

aggtranstype is the data type of the state transition values for this aggregate (resolved to an actual type, if agg's transtype is polymorphic). This is determined during planning and is InvalidOid before that.

aggargtypes is an OID list of the data types of the direct and regular arguments. Normally it's redundant with the aggdirectargs and args lists, but in a combining aggregate, it's not because the args list has been replaced with a single argument representing the partialaggregate transition values.

aggsplit indicates the expected partialaggregation mode for the Aggref's parent plan node. It's always set to AGGSPLIT_SIMPLE in the parser, but the planner might change it to something else. We use this mainly as a crosscheck that the Aggrefs match the plan; but note that when aggsplit indicates a nonfinal mode, aggtype reflects the transition data type not the SQLlevel output type of the aggregate.

Fields

aggfnoid: Oid

aggtype: Oid

aggcollid: Oid

inputcollid: Oid

aggtranstype: Oid

aggargtypes: Option<Vec<Node>>

aggdirectargs: Option<Vec<Node>>

args: Option<Vec<Node>>

aggorder: Option<Vec<Node>>

aggdistinct: Option<Vec<Node>>

aggfilter: Option<Box<Expr>>

aggstar: bool

aggvariadic: bool

aggkind: char

agglevelsup: Index

aggsplit: AggSplit

location: i32

Trait Implementations

impl Debug for Aggref

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Aggref

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for Aggref

impl PartialEq<Aggref> for Aggref

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

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

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

This method tests for !=.

impl Serialize for Aggref

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Aggref

impl StructuralPartialEq for Aggref