Struct PgAggregate 

pub struct PgAggregate {

    pub aggfnoid: SmolStr,
    pub aggkind: PgAggregateAggkind,
    pub aggnumdirectargs: u16,
    pub aggtransfn: SmolStr,
    pub aggfinalfn: Option<SmolStr>,
    pub aggcombinefn: Option<SmolStr>,
    pub aggserialfn: Option<SmolStr>,
    pub aggdeserialfn: Option<SmolStr>,
    pub aggmtransfn: Option<SmolStr>,
    pub aggminvtransfn: Option<SmolStr>,
    pub aggmfinalfn: Option<SmolStr>,
    pub aggfinalextra: bool,
    pub aggmfinalextra: bool,
    pub aggfinalmodify: PgAggregateAggfinalmodify,
    pub aggmfinalmodify: PgAggregateAggmfinalmodify,
    pub aggsortop: Option<SmolStr>,
    pub aggtranstype: SmolStr,
    pub aggmtranstype: Option<SmolStr>,
    pub agginitval: Option<SmolStr>,
    pub aggminitval: Option<SmolStr>,
}

The DDL-only contents of pg_aggregate

Fields

aggfnoid: SmolStr

regproc (references pg_proc.oid) pg_proc OID of the aggregate function

aggkind: PgAggregateAggkind

char Aggregate kind: n for “normal” aggregates, o for “ordered-set” aggregates, or h for “hypothetical-set” aggregates

aggnumdirectargs: u16

int2 Number of direct (non-aggregated) arguments of an ordered-set or hypothetical-set aggregate, counting a variadic array as one argument. If equal to pronargs, the aggregate must be variadic and the variadic array describes the aggregated arguments as well as the final direct arguments. Always zero for normal aggregates.

aggtransfn: SmolStr

regproc (references pg_proc.oid) Transition function

aggfinalfn: Option<SmolStr>

regproc (references pg_proc.oid) Final function (zero if none)

aggcombinefn: Option<SmolStr>

regproc (references pg_proc.oid) Combine function (zero if none)

aggserialfn: Option<SmolStr>

regproc (references pg_proc.oid) Serialization function (zero if none)

aggdeserialfn: Option<SmolStr>

regproc (references pg_proc.oid) Deserialization function (zero if none)

aggmtransfn: Option<SmolStr>

regproc (references pg_proc.oid) Forward transition function for moving-aggregate mode (zero if none)

aggminvtransfn: Option<SmolStr>

regproc (references pg_proc.oid) Inverse transition function for moving-aggregate mode (zero if none)

aggmfinalfn: Option<SmolStr>

regproc (references pg_proc.oid) Final function for moving-aggregate mode (zero if none)

aggfinalextra: bool

bool True to pass extra dummy arguments to aggfinalfn

aggmfinalextra: bool

bool True to pass extra dummy arguments to aggmfinalfn

aggfinalmodify: PgAggregateAggfinalmodify

char Whether aggfinalfn modifies the transition state value: r if it is read-only, s if the aggtransfn cannot be applied after the aggfinalfn, or w if it writes on the value

aggmfinalmodify: PgAggregateAggmfinalmodify

char Like aggfinalmodify, but for the aggmfinalfn

aggsortop: Option<SmolStr>

oid (references pg_operator.oid) Associated sort operator (zero if none)

aggtranstype: SmolStr

oid (references pg_type.oid) Data type of the aggregate function’s internal transition (state) data

aggmtranstype: Option<SmolStr>

oid (references pg_type.oid) Data type of the aggregate function’s internal transition (state) data for moving-aggregate mode (zero if none)

agginitval: Option<SmolStr>

text The initial value of the transition state. This is a text field containing the initial value in its external string representation. If this field is null, the transition state value starts out null.

aggminitval: Option<SmolStr>

text The initial value of the transition state for moving-aggregate mode. This is a text field containing the initial value in its external string representation. If this field is null, the transition state value starts out null.

Trait Implementations

impl Clone for PgAggregate

fn clone(&self) -> PgAggregate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PgAggregate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PgAggregate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PgAggregate

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PgAggregate

impl StructuralPartialEq for PgAggregate