Struct FunctionCall 

pub struct FunctionCall<X: Extension = NoExt> {

    pub name: ObjectName,
    pub quantifier: Option<SetQuantifier>,
    pub args: ThinVec<FunctionArg<X>>,
    pub wildcard: bool,
    pub order_by: ThinVec<OrderByExpr<X>>,
    pub within_group: Option<ThinVec<OrderByExpr<X>>>,
    pub separator: Option<Literal>,
    pub filter: Option<Box<Expr<X>>>,
    pub filter_where: FilterWhereSpelling,
    pub over: Option<WindowSpec<X>>,
    pub null_treatment: Option<NullTreatment>,
    pub window_tail: Option<WindowFunctionTail>,
    pub meta: Meta,
}

A function or aggregate call: name([DISTINCT] args | *) plus the optional aggregate modifiers an ordered-set / filtered aggregate carries.

Boxed inside Expr::Function so the hot expression enum stays within its size budget. The same canonical shape covers plain scalar calls (COALESCE, NULLIF, GREATEST, LEAST, …) and aggregates; unused modifier fields stay at their empty defaults (one shape per construct).

Fields

name: ObjectName

Name referenced by this syntax.

quantifier: Option<SetQuantifier>

The ALL / DISTINCT argument quantifier, as in count(DISTINCT x) or count(ALL x); None for a call written with no quantifier. DISTINCT ON is a SELECT-list-only form, so an aggregate never carries it.

args: ThinVec<FunctionArg<X>>

The argument list, each a positional or PostgreSQL named argument (see FunctionArg). Empty for a no-arg call or a * call.

wildcard: bool

* as the sole argument, as in count(*). Mutually exclusive with args.

order_by: ThinVec<OrderByExpr<X>>

ORDER BY inside an ordered-set aggregate, as in array_agg(x ORDER BY y).

within_group: Option<ThinVec<OrderByExpr<X>>>

WITHIN GROUP (ORDER BY <keys>) — the SQL:2008 ordered-set aggregate clause (T612/T614), as in percentile_cont(0.5) WITHIN GROUP (ORDER BY x). A post-argument clause parsed after the ), mirroring the optionality of filter and over; None when absent, and the list is non-empty when present (the grammar requires a sort key). Distinct from the in-parenthesis order_by: PostgreSQL admits at most one of the two, and they render in different positions.

separator: Option<Literal>

SEPARATOR <string> — the MySQL GROUP_CONCAT(... SEPARATOR ',') delimiter, an in-parenthesis argument tail parsed after order_by and before the closing ). Gated for acceptance by AggregateCallSyntax::group_concat_separator: None when the dialect leaves the flag off or the clause is unwritten. The delimiter is always a string constant, so it is a bare Literal rather than a general expression — one canonical field on the shared call shape, not a GROUP_CONCAT-specific node.

filter: Option<Box<Expr<X>>>

FILTER (WHERE <predicate>) applied to an aggregate.

filter_where: FilterWhereSpelling

Whether the filter clause wrote the standard WHERE keyword (FILTER (WHERE p)) or DuckDB’s keyword-less FILTER (p). A pure fidelity tag — the FilterWhereSpelling round-trips the surface spelling. Carries the canonical Where when no filter is present.

over: Option<WindowSpec<X>>

The OVER (…) / OVER name window clause that makes this a window function call; None for a plain scalar or aggregate call.

null_treatment: Option<NullTreatment>

IGNORE NULLS / RESPECT NULLS null-treatment written inside the call parentheses, after the argument list (and any in-parenthesis ORDER BY), as in DuckDB’s last(s IGNORE NULLS) OVER (…). None when unwritten. One canonical field on the shared call shape, the NullTreatment tag recording which the source used so it round-trips. Gated for acceptance by AggregateCallSyntax::null_treatment: DuckDB spells the SQL:2016 null-treatment inside the parentheses (the standard’s post-) position engine-rejects on 1.5.4), so it rides the in-parenthesis tail like separator rather than a post-argument clause. When the dialect leaves the flag off, IGNORE/RESPECT is left unconsumed and the unmatched ) surfaces as a clean parse error.

window_tail: Option<WindowFunctionTail>

The MySQL window-function post-) tail — the SQL:2016 [FROM {FIRST | LAST}] [{RESPECT | IGNORE} NULLS] clauses a null-treatment window function carries between its argument ) and its OVER clause, as in NTH_VALUE(x, 2) FROM FIRST RESPECT NULLS OVER (…). None when no tail was written. A separate field from the in-parenthesis DuckDB null_treatment precisely because the surface position differs: MySQL spells these after the ) and rejects the in-paren spelling (ER_PARSE_ERROR, 1064), while DuckDB rejects the post-) one — so the two positions round-trip as distinct fields on the shared call shape rather than a shared field plus a position tag the DuckDB path would also carry. Gated for acceptance by AggregateCallSyntax::window_function_tail: MySQL admits it only on the null-treatment window functions (LEAD/LAG/FIRST_VALUE/LAST_VALUE/NTH_VALUE, with FROM FIRST on NTH_VALUE alone), enforced by the parser’s window-grammar gate.

meta: Meta

Source location and node identity.

Trait Implementations

impl<X: Clone + Extension> Clone for FunctionCall<X>

fn clone(&self) -> FunctionCall<X>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Debug + Extension> Debug for FunctionCall<X>

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

Formats the value using the given formatter.

impl<'de, X> Deserialize<'de> for FunctionCall<X>

where X: Deserialize<'de> + Extension,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X: Eq + Extension> Eq for FunctionCall<X>

impl<X: Hash + Extension> Hash for FunctionCall<X>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<X: PartialEq + Extension> PartialEq for FunctionCall<X>

fn eq(&self, other: &FunctionCall<X>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<X: Extension + Render> Render for FunctionCall<X>

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

Return the render for this value.

fn operand_binding_power(&self) -> Option<BindingPower>

The binding power this node contributes when it appears as an operand, or None (the default) for a self-delimiting node — an atom, call, or constructor — that never needs parentheses.

impl<X> Serialize for FunctionCall<X>

where X: Serialize + Extension,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: Extension> Spanned for FunctionCall<X>

fn span(&self) -> Span

Return the span for this value.

impl<X: PartialEq + Extension> StructuralPartialEq for FunctionCall<X>