Enum postgres_parser::sys::GroupingSetKind

#[repr(u32)]pub enum GroupingSetKind {
    GROUPING_SET_EMPTY,
    GROUPING_SET_SIMPLE,
    GROUPING_SET_ROLLUP,
    GROUPING_SET_CUBE,
    GROUPING_SET_SETS,
}

GroupingSet representation of CUBE, ROLLUP and GROUPING SETS clauses

In a Query with grouping sets, the groupClause contains a flat list of SortGroupClause nodes for each distinct expression used. The actual structure of the GROUP BY clause is given by the groupingSets tree.

In the raw parser output, GroupingSet nodes (of all types except SIMPLE which is not used) are potentially mixed in with the expressions in the groupClause of the SelectStmt. (An expression can't contain a GroupingSet, but a list may mix GroupingSet and expression nodes.) At this stage, the content of each node is a list of expressions, some of which may be RowExprs which represent sublists rather than actual row constructors, and nested GroupingSet nodes where legal in the grammar. The structure directly reflects the query syntax.

In parse analysis, the transformed expressions are used to build the tlist and groupClause list (of SortGroupClause nodes), and the groupingSets tree is eventually reduced to a fixed format:

EMPTY nodes represent (), and obviously have no content

SIMPLE nodes represent a list of one or more expressions to be treated as an atom by the enclosing structure; the content is an integer list of ressortgroupref values (see SortGroupClause)

CUBE and ROLLUP nodes contain a list of one or more SIMPLE nodes.

SETS nodes contain a list of EMPTY, SIMPLE, CUBE or ROLLUP nodes, but after parse analysis they cannot contain more SETS nodes; enough of the syntactic transforms of the spec have been applied that we no longer have arbitrarily deep nesting (though we still preserve the use of cube/rollup).

Note that if the groupingSets tree contains no SIMPLE nodes (only EMPTY nodes at the leaves), then the groupClause will be empty, but this is still an aggregation query (similar to using aggs or HAVING without GROUP BY).

As an example, the following clause:

GROUP BY GROUPING SETS ((a,b), CUBE(c,(d,e)))

looks like this after raw parsing:

SETS( RowExpr(a,b) , CUBE( c, RowExpr(d,e) ) )

and parse analysis converts it to:

SETS( SIMPLE(1,2), CUBE( SIMPLE(3), SIMPLE(4,5) ) )

Variants

GROUPING_SET_EMPTY

GROUPING_SET_SIMPLE

GROUPING_SET_ROLLUP

GROUPING_SET_CUBE

GROUPING_SET_SETS

Trait Implementations

impl Clone for GroupingSetKind

fn clone(&self) -> GroupingSetKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for GroupingSetKind

impl Debug for GroupingSetKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GroupingSetKind

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

Deserialize this value from the given Serde deserializer.

impl Eq for GroupingSetKind

impl Hash for GroupingSetKind

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, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<GroupingSetKind> for GroupingSetKind

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for GroupingSetKind

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 GroupingSetKind

impl StructuralPartialEq for GroupingSetKind