Enum good_ormning::sqlite::queries::expr::Expr

pub enum Expr {
    LitNull(SimpleType),
    LitBool(bool),
    LitI32(i32),
    LitI64(i64),
    LitU32(u32),
    LitF32(f32),
    LitF64(f64),
    LitString(String),
    LitBytes(Vec<u8>),
    LitUtcTimeS(DateTime<Utc>),
    LitUtcTimeMs(DateTime<Utc>),
    Param {
        name: String,
        type_: Type,
    },
    Field(FieldId),
    BinOp {
        left: Box<Expr>,
        op: BinOp,
        right: Box<Expr>,
    },
    BinOpChain {
        op: BinOp,
        exprs: Vec<Expr>,
    },
    PrefixOp {
        op: PrefixOp,
        right: Box<Expr>,
    },
    Call {
        func: String,
        type_: Type,
        args: Vec<Expr>,
    },
    Select(Box<Select>),
    Cast(Box<Expr>, Type),
}

Variants

LitNull(SimpleType)

LitBool(bool)

LitI32(i32)

LitI64(i64)

LitU32(u32)

LitF32(f32)

LitF64(f64)

LitString(String)

LitBytes(Vec<u8>)

LitUtcTimeS(DateTime<Utc>)

LitUtcTimeMs(DateTime<Utc>)

Param

Fields

name: String

type_: Type

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

Field(FieldId)

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

Fields

op: BinOp

exprs: Vec<Expr>

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.

PrefixOp

Fields

op: PrefixOp

right: Box<Expr>

Call

Fields

func: String

type_: Type

args: Vec<Expr>

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

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 copy 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.