Enum FunctionArgumentClause 

pub enum FunctionArgumentClause {
    IgnoreOrRespectNulls(NullTreatment),
    OrderBy(Vec<OrderByExpr>),
    Limit(Expr),
    OnOverflow(ListAggOnOverflow),
    Having(HavingBound),
    Separator(Value),
    JsonNullClause(JsonNullClause),
    JsonReturningClause(JsonReturningClause),
}

Variants

IgnoreOrRespectNulls(NullTreatment)

Indicates how NULLs should be handled in the calculation, e.g. in FIRST_VALUE on BigQuery.

Syntax:

{ IGNORE | RESPECT } NULLS ]

OrderBy(Vec<OrderByExpr>)

Specifies the the ordering for some ordered set aggregates, e.g. ARRAY_AGG on BigQuery.

Limit(Expr)

Specifies a limit for the ARRAY_AGG and ARRAY_CONCAT_AGG functions on BigQuery.

OnOverflow(ListAggOnOverflow)

Specifies the behavior on overflow of the LISTAGG function.

See https://trino.io/docs/current/functions/aggregate.html.

Having(HavingBound)

Specifies a minimum or maximum bound on the input to ANY_VALUE on BigQuery.

Syntax:

HAVING { MAX | MIN } expression

Separator(Value)

The SEPARATOR clause to the GROUP_CONCAT function in MySQL.

JsonNullClause(JsonNullClause)

The ON NULL clause for some JSON functions.

MSSQL JSON_ARRAY MSSQL JSON_OBJECT PostgreSQL JSON functions

JsonReturningClause(JsonReturningClause)

The RETURNING clause for some JSON functions in PostgreSQL

JSON_OBJECT

Trait Implementations

impl Clone for FunctionArgumentClause

fn clone(&self) -> FunctionArgumentClause

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionArgumentClause

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

Formats the value using the given formatter.

impl Display for FunctionArgumentClause

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

Formats the value using the given formatter.

impl Hash for FunctionArgumentClause

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 Ord for FunctionArgumentClause

fn cmp(&self, other: &FunctionArgumentClause) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for FunctionArgumentClause

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

fn partial_cmp(&self, other: &FunctionArgumentClause) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Spanned for FunctionArgumentClause

fn span(&self) -> Span

Return the Span (the minimum and maximum Location) for this AST node, by recursively combining the spans of its children.

impl Visit for FunctionArgumentClause

fn visit<V>(&self, visitor: &mut V) -> ControlFlow<<V as Visitor>::Break>

where V: Visitor,

impl VisitMut for FunctionArgumentClause

fn visit<V>(&mut self, visitor: &mut V) -> ControlFlow<<V as VisitorMut>::Break>

where V: VisitorMut,

impl Eq for FunctionArgumentClause

impl StructuralPartialEq for FunctionArgumentClause