Enum Expr 

pub enum Expr {
    LitArray(Vec<Expr>),
    LitNull(SimpleType),
    LitBool(bool),
    LitAuto(i64),
    LitI32(i32),
    LitI64(i64),
    LitF32(f32),
    LitF64(f64),
    LitString(String),
    LitBytes(Vec<u8>),
    LitUtcTimeChrono(DateTime<Utc>),
    LitFixedOffsetTimeChrono(DateTime<FixedOffset>),
    LitUtcTimeJiff(Timestamp),
    Param {
        name: String,
        type_: Type,
    },
    Field(Field),
    BinOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    BinOpChain {
        op: BinOp,
        exprs: Vec<Expr>,
    },
    PrefixOp {
        op: PrefixOp,
        right: Box<Expr>,
    },
    Call {
        func: String,
        args: Vec<Expr>,
        compute_type: ComputeType,
    },
    Select(Box<Select>),
    Cast(Box<Expr>, Type),
}

Variants

LitArray(Vec<Expr>)

LitNull(SimpleType)

LitBool(bool)

LitAuto(i64)

LitI32(i32)

LitI64(i64)

LitF32(f32)

LitF64(f64)

LitString(String)

LitBytes(Vec<u8>)

LitUtcTimeChrono(DateTime<Utc>)

LitFixedOffsetTimeChrono(DateTime<FixedOffset>)

LitUtcTimeJiff(Timestamp)

Param

A query parameter. This will become a parameter to the generated Rust function with the specified name and type_.

Fields

name: String

type_: Type

Field(Field)

This evaluates to the value of a field in the query main or joined tables. If you’ve aliased tables or field names, you’ll have to instantiate FieldId yourself with the appropriate values. For synthetic values like function results you may need a FieldId with an empty TableId ("").

BinOp

Fields

left: Box<Expr>

op: BinOp

right: Box<Expr>

BinOpChain

This is the same as BinOp but allows chaining multiple expressions with the same operator. This can be useful if you have many successive ANDs or similar.

Fields

op: BinOp

exprs: Vec<Expr>

PrefixOp

Fields

op: PrefixOp

right: Box<Expr>

Call

Represents a call to an SQL function, like collate(). You must provide a helper to check and determine type of the result since we don’t have a table of functions and their return types at present.

Fields

func: String

args: Vec<Expr>

compute_type: ComputeType

Select(Box<Select>)

A sub SELECT query.

Cast(Box<Expr>, Type)

This is a synthetic expression, saying to treat the result of the expression as having the specified type. Use this for casting between primitive types and Rust new-types for instance.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.