Enum gluesql_core::ast_builder::FunctionNode

pub enum FunctionNode {
Show 47 variants
    Abs(ExprNode),
    Upper(ExprNode),
    IfNull {
        expr: ExprNode,
        then: ExprNode,
    },
    Ceil(ExprNode),
    Round(ExprNode),
    Floor(ExprNode),
    Asin(ExprNode),
    Acos(ExprNode),
    Atan(ExprNode),
    Sin(ExprNode),
    Cos(ExprNode),
    Tan(ExprNode),
    Pi,
    Now,
    Left {
        expr: ExprNode,
        size: ExprNode,
    },
    Log {
        antilog: ExprNode,
        base: ExprNode,
    },
    Log2(ExprNode),
    Log10(ExprNode),
    Ln(ExprNode),
    Right {
        expr: ExprNode,
        size: ExprNode,
    },
    Reverse(ExprNode),
    Sign(ExprNode),
    Power {
        expr: ExprNode,
        power: ExprNode,
    },
    Sqrt(ExprNode),
    Gcd {
        left: ExprNode,
        right: ExprNode,
    },
    Lcm {
        left: ExprNode,
        right: ExprNode,
    },
    GenerateUuid,
    Repeat {
        expr: ExprNode,
        num: ExprNode,
    },
    Exp(ExprNode),
    Lpad {
        expr: ExprNode,
        size: ExprNode,
        fill: Option<ExprNode>,
    },
    Rpad {
        expr: ExprNode,
        size: ExprNode,
        fill: Option<ExprNode>,
    },
    Degrees(ExprNode),
    Radians(ExprNode),
    Concat(ExprList),
    Substr {
        expr: ExprNode,
        start: ExprNode,
        count: Option<ExprNode>,
    },
    Ltrim {
        expr: ExprNode,
        chars: Option<ExprNode>,
    },
    Rtrim {
        expr: ExprNode,
        chars: Option<ExprNode>,
    },
    Div {
        dividend: ExprNode,
        divisor: ExprNode,
    },
    Mod {
        dividend: ExprNode,
        divisor: ExprNode,
    },
    Format {
        expr: ExprNode,
        format: ExprNode,
    },
    ToDate {
        expr: ExprNode,
        format: ExprNode,
    },
    ToTimestamp {
        expr: ExprNode,
        format: ExprNode,
    },
    ToTime {
        expr: ExprNode,
        format: ExprNode,
    },
    Lower(ExprNode),
    Position {
        from_expr: ExprNode,
        sub_expr: ExprNode,
    },
    Cast {
        expr: ExprNode,
        data_type: DataTypeNode,
    },
    Extract {
        field: DateTimeField,
        expr: ExprNode,
    },
}

Expand description

Available aggregate or normal SQL functions

Variants

`Abs(ExprNode)`

`Upper(ExprNode)`

`IfNull`

Fields

expr: ExprNode

then: ExprNode

`Ceil(ExprNode)`

`Round(ExprNode)`

`Floor(ExprNode)`

`Asin(ExprNode)`

`Acos(ExprNode)`

`Atan(ExprNode)`

`Sin(ExprNode)`

`Cos(ExprNode)`

`Tan(ExprNode)`

`Pi`

`Now`

`Left`

Fields

expr: ExprNode

size: ExprNode

`Log`

Fields

antilog: ExprNode

base: ExprNode

`Log2(ExprNode)`

`Log10(ExprNode)`

`Ln(ExprNode)`

`Right`

Fields

expr: ExprNode

size: ExprNode

`Reverse(ExprNode)`

`Sign(ExprNode)`

`Power`

Fields

expr: ExprNode

power: ExprNode

`Sqrt(ExprNode)`

`Gcd`

Fields

left: ExprNode

right: ExprNode

`Lcm`

Fields

left: ExprNode

right: ExprNode

`GenerateUuid`

`Repeat`

Fields

expr: ExprNode

num: ExprNode

`Exp(ExprNode)`

`Lpad`

Fields

expr: ExprNode

size: ExprNode

fill: Option<ExprNode>

`Rpad`

Fields

expr: ExprNode

size: ExprNode

fill: Option<ExprNode>

`Degrees(ExprNode)`

`Radians(ExprNode)`

`Concat(ExprList)`

`Substr`

Fields

expr: ExprNode

start: ExprNode

count: Option<ExprNode>

`Ltrim`

Fields

expr: ExprNode

chars: Option<ExprNode>

`Rtrim`

Fields

expr: ExprNode

chars: Option<ExprNode>

`Div`

Fields

dividend: ExprNode

divisor: ExprNode

`Mod`

Fields

dividend: ExprNode

divisor: ExprNode

`Format`

Fields

expr: ExprNode

format: ExprNode

`ToDate`

Fields

expr: ExprNode

format: ExprNode

`ToTimestamp`

Fields

expr: ExprNode

format: ExprNode

`ToTime`

Fields

expr: ExprNode

format: ExprNode

`Lower(ExprNode)`

`Position`

Fields

from_expr: ExprNode

sub_expr: ExprNode

`Cast`

Fields

expr: ExprNode

data_type: DataTypeNode

`Extract`

Fields

field: DateTimeField

expr: ExprNode

Trait Implementations

impl Clone for FunctionNode

fn clone(&self) -> FunctionNode

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

impl TryFrom<FunctionNode> for Function

type Error = Error

The type returned in the event of a conversion error.

fn try_from(func_node: FunctionNode) -> Result<Self>

Performs the conversion.

Auto Trait Implementations

impl RefUnwindSafe for FunctionNode

impl Send for FunctionNode

impl Sync for FunctionNode

impl Unpin for FunctionNode

impl UnwindSafe for FunctionNode

Blanket Implementations

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.