Struct postgres_parser::sys::FuncCall

#[repr(C)]pub struct FuncCall {
    pub type_: NodeTag,
    pub funcname: *mut List,
    pub args: *mut List,
    pub agg_order: *mut List,
    pub agg_filter: *mut Node,
    pub agg_within_group: bool,
    pub agg_star: bool,
    pub agg_distinct: bool,
    pub func_variadic: bool,
    pub over: *mut WindowDef,
    pub location: c_int,
}

FuncCall a function or aggregate invocation

agg_order (if not NIL) indicates we saw 'foo(... ORDER BY ...)', or if agg_within_group is true, it was 'foo(...) WITHIN GROUP (ORDER BY ...)'. agg_star indicates we saw a 'foo(*)' construct, while agg_distinct indicates we saw 'foo(DISTINCT ...)'. In any of these cases, the construct must be an aggregate call. Otherwise, it might be either an aggregate or some other kind of function. However, if FILTER or OVER is present it had better be an aggregate or window function.

Normally, you'd initialize this via makeFuncCall() and then only change the parts of the struct its defaults don't match afterwards, as needed.

Fields

type_: NodeTag

funcname: *mut List

args: *mut List

qualified name of function

agg_order: *mut List

the arguments (list of exprs)

agg_filter: *mut Node

ORDER BY (list of SortBy)

agg_within_group: bool

FILTER clause, if any

agg_star: bool

ORDER BY appeared in WITHIN GROUP

agg_distinct: bool

argument was really '*'

func_variadic: bool

arguments were labeled DISTINCT

over: *mut WindowDef

last argument was labeled VARIADIC

location: c_int

OVER clause, if any

Trait Implementations

impl Debug for FuncCall

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

Formats the value using the given formatter.

impl Default for FuncCall

fn default() -> Self

Returns the "default value" for a type.

impl Eq for FuncCall

impl Hash for FuncCall

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<FuncCall> for FuncCall

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

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

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

This method tests for !=.

impl StructuralEq for FuncCall

impl StructuralPartialEq for FuncCall