Trait Expression 

pub trait Expression {
    type SqlType: TypedExpressionType;
}

Represents a typed fragment of SQL.

Apps should not need to implement this type directly, but it may be common to use this in where clauses. Libraries should consider using infix_operator! or postfix_operator! instead of implementing this directly.

Required Associated Types

type SqlType: TypedExpressionType

The type that this expression represents in SQL

Implementations on Foreign Types

impl<T: Expression + ?Sized> Expression for &T

type SqlType = <T as Expression>::SqlType

impl<T: Expression + ?Sized> Expression for Box<T>

type SqlType = <T as Expression>::SqlType

impl<T: Expression> Expression for (T₁, T₂, …, Tₙ)

where (T::SqlType,): TypedExpressionType,

type SqlType = (<T as Expression>::SqlType,)

Implementors

impl Expression for now

type SqlType = Timestamp

impl Expression for today

type SqlType = Date

impl<L, R, ST> Expression for Concat<L, R>

where L: Expression<SqlType = ST>, R: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

type SqlType = ST

impl<Query, Value> Expression for UncheckedBind<Query, Value>

where Query: Expression,

type SqlType = <Query as Expression>::SqlType

impl<S, C> Expression for AliasedField<S, C>

where S: AliasSource, C: Column<Table = S::Target> + Expression,

type SqlType = <C as Expression>::SqlType

impl<ST, I> Expression for Many<ST, I>

where ST: TypedExpressionType,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

type SqlType = NotSelectable

impl<ST, T> Expression for SqlLiteral<ST, T>

where ST: TypedExpressionType,

type SqlType = ST

impl<T> Expression for Exists<T>

where Subselect<T, Bool>: Expression,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

type SqlType = Bool

impl<T, U> Expression for In<T, U>

where T: Expression, U: InExpression<SqlType = T::SqlType>, T::SqlType: SqlType, IsSqlTypeNullable<T::SqlType>: MaybeNullableType<Bool>,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

type SqlType = <<<T as Expression>::SqlType as SqlType>::IsNull as MaybeNullableType<Bool>>::Out

impl<T, U> Expression for NotIn<T, U>

where T: Expression, U: InExpression<SqlType = T::SqlType>, T::SqlType: SqlType, IsSqlTypeNullable<T::SqlType>: MaybeNullableType<Bool>,

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

type SqlType = <<<T as Expression>::SqlType as SqlType>::IsNull as MaybeNullableType<Bool>>::Out

impl<W, T> Expression for CaseWhen<CaseWhenConditionsLeaf<W, T>, NoElseExpression>

where W: Expression, <W as Expression>::SqlType: BoolOrNullableBool, T: Expression, <T as Expression>::SqlType: IntoNullable, <<T as Expression>::SqlType as IntoNullable>::Nullable: SqlType + TypedExpressionType,

type SqlType = <<T as Expression>::SqlType as IntoNullable>::Nullable

impl<W, T, E> Expression for CaseWhen<CaseWhenConditionsLeaf<W, T>, ElseExpression<E>>

where W: Expression, <W as Expression>::SqlType: BoolOrNullableBool, T: Expression,

type SqlType = <T as Expression>::SqlType

impl<W, T, Whens, E> Expression for CaseWhen<CaseWhenConditionsIntermediateNode<W, T, Whens>, E>

where CaseWhen<CaseWhenConditionsLeaf<W, T>, E>: Expression, CaseWhen<Whens, E>: Expression<SqlType = <CaseWhen<CaseWhenConditionsLeaf<W, T>, E> as Expression>::SqlType>,

type SqlType = <CaseWhen<CaseWhenConditionsLeaf<W, T>, E> as Expression>::SqlType