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

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

type SqlType = <T as Expression>::SqlType

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

type SqlType = <T as Expression>::SqlType

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

type SqlType = <T as Expression>::SqlType

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

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: QueryRelationField<QueryRelation = 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, C> Expression for Collate<T, C>

where T: Expression,

type SqlType = <T as Expression>::SqlType

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

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