Trait diesel::expression::AsExpression[−][src]

pub trait AsExpression<T> {
    type Expression: Expression<SqlType = T>;
    fn as_expression(self) -> Self::Expression;
}

Converts a type to its representation for use in Diesel's query builder.

This trait is used directly. Apps should typically use IntoSql instead.

Implementations of this trait will generally do one of 3 things:

Return self for types which are already parts of Diesel's query builder
Perform some implicit coercion (for example, allowing now to be used as both Timestamp and Timestamptz.
Indicate that the type has data which will be sent separately from the query. This is generally referred as a "bind parameter". Types which implement ToSql will generally implement AsExpression this way.

Deriving

This trait can be automatically derived for any type which implements ToSql. The type must be annotated with #[sql_type = "SomeType"]. If that annotation appears multiple times, implementations will be generated for each one of them.

This will generate the following impls:

impl AsExpression<SqlType> for YourType
impl AsExpression<Nullable<SqlType>> for YourType
impl AsExpression<SqlType> for &'a YourType
impl AsExpression<Nullable<SqlType>> for &'a YourType
impl AsExpression<SqlType> for &'a &'b YourType
impl AsExpression<Nullable<SqlType>> for &'a &'b YourType

If your type is unsized, you can specify this by adding the annotation #[diesel(not_sized)]. This will skip the impls for non-reference types.

Associated Types

`type Expression: Expression<SqlType = T>`

The expression being returned

Required Methods

`fn as_expression(self) -> Self::Expression`

Perform the conversion

Implementations on Foreign Types

`impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a [T]`
[src]

`type Expression = Bound<Array<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a [T]`
[src]

`type Expression = Bound<Nullable<Array<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b [T]`
[src]

`type Expression = Bound<Array<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b [T]`
[src]

`type Expression = Bound<Nullable<Array<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Array<ST>> for Vec<T>`
[src]

`type Expression = Bound<Array<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for Vec<T>`
[src]

`type Expression = Bound<Nullable<Array<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a Vec<T>`
[src]

`type Expression = Bound<Array<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a Vec<T>`
[src]

`type Expression = Bound<Nullable<Array<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b Vec<T>`
[src]

`type Expression = Bound<Array<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b Vec<T>`
[src]

`type Expression = Bound<Nullable<Array<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<ST, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>)`
[src]

`type Expression = SqlBound<Range<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, ST, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>)`
[src]

`type Expression = SqlBound<Range<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<ST, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>)`
[src]

`type Expression = SqlBound<Nullable<Range<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, ST, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>)`
[src]

`type Expression = SqlBound<Nullable<Range<ST>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, SA> AsExpression<Record<(SA,)>> for (A,) where A: AsExpression<SA>, PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,`
[src]

`type Expression = PgTuple<(A::Expression,)>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, B, SA, SB> AsExpression<Record<(SA, SB)>> for (A, B) where A: AsExpression<SA>, B: AsExpression<SB>, PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,`
[src]

`type Expression = PgTuple<(A::Expression, B::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, B, C, SA, SB, SC> AsExpression<Record<(SA, SB, SC)>> for (A, B, C) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,`
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, B, C, D, SA, SB, SC, SD> AsExpression<Record<(SA, SB, SC, SD)>> for (A, B, C, D) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,`
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, B, C, D, E, SA, SB, SC, SD, SE> AsExpression<Record<(SA, SB, SC, SD, SE)>> for (A, B, C, D, E) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,`
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> AsExpression<Record<(SA, SB, SC, SD, SE, SF)>> for (A, B, C, D, E, F) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,`
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>> for (A, B, C, D, E, F, G) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>> for (A, B, C, D, E, F, G, H) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>> for (A, B, C, D, E, F, G, H, I) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>> for (A, B, C, D, E, F, G, H, I, J) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>> for (A, B, C, D, E, F, G, H, I, J, K) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>> for (A, B, C, D, E, F, G, H, I, J, K, L) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, AC: AsExpression<SAC>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, AC: AsExpression<SAC>, AD: AsExpression<SAD>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, AC: AsExpression<SAC>, AD: AsExpression<SAD>, AE: AsExpression<SAE>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>,
[src]

`type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)>`

`fn as_expression(self) -> Self::Expression`
[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) where A: AsExpression<SA>, B: AsExpression<SB>, C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, F: AsExpression<SF>, G: AsExpression<SG>, H: AsExpression<SH>, I: AsExpression<SI>, J: AsExpression<SJ>, K: AsExpression<SK>, L: AsExpression<SL>, M: AsExpression<SM>, N: AsExpression<SN>, O: AsExpression<SO>, P: AsExpression<SP>, Q: AsExpression<SQ>, R: AsExpression<SR>, S: AsExpression<SS>, T: AsExpression<ST>, U: AsExpression<SU>, V: AsExpression<SV>, W: AsExpression<SW>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, AC: AsExpression<SAC>, AD: AsExpression<SAD>, AE: AsExpression<SAE>, AF: AsExpression<SAF>, PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>,
[src]

type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)>

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Timestamp> for &'expr SystemTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr SystemTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr SystemTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr SystemTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Timestamp> for SystemTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Timestamp>> for SystemTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Date> for &'expr NaiveDate`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Date>> for &'expr NaiveDate`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr NaiveDate`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr NaiveDate`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Date> for NaiveDate`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Date>> for NaiveDate`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Time> for &'expr NaiveTime`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Time>> for &'expr NaiveTime`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr NaiveTime`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr NaiveTime`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Time> for NaiveTime`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Time>> for NaiveTime`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Timestamp> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Timestamp> for NaiveDateTime`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Timestamp>> for NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Timestamptz> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Timestamptz> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Timestamptz> for NaiveDateTime`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Timestamptz>> for NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Datetime> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Datetime, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Datetime>> for &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Datetime>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Datetime> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Datetime, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Datetime>> for &'expr2 &'expr NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Datetime>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Datetime> for NaiveDateTime`
[src]

`type Expression = Bound<Datetime, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Datetime>> for NaiveDateTime`
[src]

`type Expression = Bound<Nullable<Datetime>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr DateTime<Tz>`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr DateTime<Tz>`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr2 &'expr DateTime<Tz>`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr DateTime<Tz>`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<Tz: TimeZone> AsExpression<Timestamptz> for DateTime<Tz>`
[src]

`type Expression = Bound<Timestamptz, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for DateTime<Tz>`
[src]

`type Expression = Bound<Nullable<Timestamptz>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<T, ST> AsExpression<Nullable<ST>> for Option<T> where ST: NotNull,`
[src]

`type Expression = Bound<Nullable<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, T, ST> AsExpression<Nullable<ST>> for &'a Option<T> where ST: NotNull,`
[src]

`type Expression = Bound<Nullable<ST>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Bool> for &'expr bool`
[src]

`type Expression = Bound<Bool, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Bool>> for &'expr bool`
[src]

`type Expression = Bound<Nullable<Bool>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Bool> for &'expr2 &'expr bool`
[src]

`type Expression = Bound<Bool, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Bool>> for &'expr2 &'expr bool`
[src]

`type Expression = Bound<Nullable<Bool>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Bool> for bool`
[src]

`type Expression = Bound<Bool, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Bool>> for bool`
[src]

`type Expression = Bound<Nullable<Bool>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Tinyint> for &'expr i8`
[src]

`type Expression = Bound<Tinyint, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Tinyint>> for &'expr i8`
[src]

`type Expression = Bound<Nullable<Tinyint>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Tinyint> for &'expr2 &'expr i8`
[src]

`type Expression = Bound<Tinyint, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Tinyint>> for &'expr2 &'expr i8`
[src]

`type Expression = Bound<Nullable<Tinyint>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Tinyint> for i8`
[src]

`type Expression = Bound<Tinyint, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Tinyint>> for i8`
[src]

`type Expression = Bound<Nullable<Tinyint>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<SmallInt> for &'expr i16`
[src]

`type Expression = Bound<SmallInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<SmallInt>> for &'expr i16`
[src]

`type Expression = Bound<Nullable<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<SmallInt> for &'expr2 &'expr i16`
[src]

`type Expression = Bound<SmallInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<SmallInt>> for &'expr2 &'expr i16`
[src]

`type Expression = Bound<Nullable<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<SmallInt> for i16`
[src]

`type Expression = Bound<SmallInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<SmallInt>> for i16`
[src]

`type Expression = Bound<Nullable<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Integer> for &'expr i32`
[src]

`type Expression = Bound<Integer, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Integer>> for &'expr i32`
[src]

`type Expression = Bound<Nullable<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Integer> for &'expr2 &'expr i32`
[src]

`type Expression = Bound<Integer, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Integer>> for &'expr2 &'expr i32`
[src]

`type Expression = Bound<Nullable<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Integer> for i32`
[src]

`type Expression = Bound<Integer, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Integer>> for i32`
[src]

`type Expression = Bound<Nullable<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<BigInt> for &'expr i64`
[src]

`type Expression = Bound<BigInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<BigInt>> for &'expr i64`
[src]

`type Expression = Bound<Nullable<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<BigInt> for &'expr2 &'expr i64`
[src]

`type Expression = Bound<BigInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<BigInt>> for &'expr2 &'expr i64`
[src]

`type Expression = Bound<Nullable<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<BigInt> for i64`
[src]

`type Expression = Bound<BigInt, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<BigInt>> for i64`
[src]

`type Expression = Bound<Nullable<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Unsigned<SmallInt>> for &'expr u16`
[src]

`type Expression = Bound<Unsigned<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Unsigned<SmallInt>>> for &'expr u16`
[src]

`type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Unsigned<SmallInt>> for &'expr2 &'expr u16`
[src]

`type Expression = Bound<Unsigned<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<SmallInt>>> for &'expr2 &'expr u16`
[src]

`type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Unsigned<SmallInt>> for u16`
[src]

`type Expression = Bound<Unsigned<SmallInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Unsigned<SmallInt>>> for u16`
[src]

`type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Unsigned<Integer>> for &'expr u32`
[src]

`type Expression = Bound<Unsigned<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Unsigned<Integer>>> for &'expr u32`
[src]

`type Expression = Bound<Nullable<Unsigned<Integer>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Unsigned<Integer>> for &'expr2 &'expr u32`
[src]

`type Expression = Bound<Unsigned<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<Integer>>> for &'expr2 &'expr u32`
[src]

`type Expression = Bound<Nullable<Unsigned<Integer>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Unsigned<Integer>> for u32`
[src]

`type Expression = Bound<Unsigned<Integer>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Unsigned<Integer>>> for u32`
[src]

`type Expression = Bound<Nullable<Unsigned<Integer>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Oid> for &'expr u32`
[src]

`type Expression = Bound<Oid, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Oid>> for &'expr u32`
[src]

`type Expression = Bound<Nullable<Oid>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Oid> for &'expr2 &'expr u32`
[src]

`type Expression = Bound<Oid, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Oid>> for &'expr2 &'expr u32`
[src]

`type Expression = Bound<Nullable<Oid>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Oid> for u32`
[src]

`type Expression = Bound<Oid, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Oid>> for u32`
[src]

`type Expression = Bound<Nullable<Oid>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Unsigned<BigInt>> for &'expr u64`
[src]

`type Expression = Bound<Unsigned<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Unsigned<BigInt>>> for &'expr u64`
[src]

`type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Unsigned<BigInt>> for &'expr2 &'expr u64`
[src]

`type Expression = Bound<Unsigned<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<BigInt>>> for &'expr2 &'expr u64`
[src]

`type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Unsigned<BigInt>> for u64`
[src]

`type Expression = Bound<Unsigned<BigInt>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Unsigned<BigInt>>> for u64`
[src]

`type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Float> for &'expr f32`
[src]

`type Expression = Bound<Float, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Float>> for &'expr f32`
[src]

`type Expression = Bound<Nullable<Float>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Float> for &'expr2 &'expr f32`
[src]

`type Expression = Bound<Float, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Float>> for &'expr2 &'expr f32`
[src]

`type Expression = Bound<Nullable<Float>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Float> for f32`
[src]

`type Expression = Bound<Float, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Float>> for f32`
[src]

`type Expression = Bound<Nullable<Float>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Double> for &'expr f64`
[src]

`type Expression = Bound<Double, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Double>> for &'expr f64`
[src]

`type Expression = Bound<Nullable<Double>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Double> for &'expr2 &'expr f64`
[src]

`type Expression = Bound<Double, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Double>> for &'expr2 &'expr f64`
[src]

`type Expression = Bound<Nullable<Double>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Double> for f64`
[src]

`type Expression = Bound<Double, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Double>> for f64`
[src]

`type Expression = Bound<Nullable<Double>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Text> for &'expr String`
[src]

`type Expression = Bound<Text, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Text>> for &'expr String`
[src]

`type Expression = Bound<Nullable<Text>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Text> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Text, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Text>> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Nullable<Text>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Text> for String`
[src]

`type Expression = Bound<Text, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Text>> for String`
[src]

`type Expression = Bound<Nullable<Text>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Date> for &'expr String`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Date>> for &'expr String`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Date> for String`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Date>> for String`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Time> for &'expr String`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Time>> for &'expr String`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Time> for String`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Time>> for String`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Timestamp> for &'expr String`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr String`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr String`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Timestamp> for String`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Timestamp>> for String`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Text> for &'expr str`
[src]

`type Expression = Bound<Text, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Text>> for &'expr str`
[src]

`type Expression = Bound<Nullable<Text>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Text> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Text, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Text>> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Nullable<Text>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Date> for &'expr str`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Date>> for &'expr str`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Date, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Nullable<Date>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Time> for &'expr str`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Time>> for &'expr str`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Time, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Nullable<Time>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Timestamp> for &'expr str`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr str`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Timestamp, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr str`
[src]

`type Expression = Bound<Nullable<Timestamp>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Binary> for &'expr Vec<u8>`
[src]

`type Expression = Bound<Binary, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Binary>> for &'expr Vec<u8>`
[src]

`type Expression = Bound<Nullable<Binary>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Binary> for &'expr2 &'expr Vec<u8>`
[src]

`type Expression = Bound<Binary, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Binary>> for &'expr2 &'expr Vec<u8>`
[src]

`type Expression = Bound<Nullable<Binary>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Binary> for Vec<u8>`
[src]

`type Expression = Bound<Binary, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl AsExpression<Nullable<Binary>> for Vec<u8>`
[src]

`type Expression = Bound<Nullable<Binary>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Binary> for &'expr [u8]`
[src]

`type Expression = Bound<Binary, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr> AsExpression<Nullable<Binary>> for &'expr [u8]`
[src]

`type Expression = Bound<Nullable<Binary>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Binary> for &'expr2 &'expr [u8]`
[src]

`type Expression = Bound<Binary, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'expr2, 'expr> AsExpression<Nullable<Binary>> for &'expr2 &'expr [u8]`
[src]

`type Expression = Bound<Nullable<Binary>, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, T: ?Sized, ST> AsExpression<ST> for Cow<'a, T> where T: 'a + ToOwned, Bound<ST, Cow<'a, T>>: Expression<SqlType = ST>,`
[src]

`type Expression = Bound<ST, Self>`

`fn as_expression(self) -> Self::Expression`
[src]

`impl<'a, 'b, T: ?Sized, ST> AsExpression<ST> for &'b Cow<'a, T> where T: 'a + ToOwned, Bound<ST, &'b T>: Expression<SqlType = ST>,`
[src]

`type Expression = Bound<ST, &'b T>`

`fn as_expression(self) -> Self::Expression`
[src]

Implementors

impl AsExpression<Timestamptz> for now type Expression = Coerce<now, Timestamptz>;
[src]
impl AsExpression<Nullable<Timestamptz>> for now type Expression = Coerce<now, Nullable<Timestamptz>>;
[src]
impl<T: Expression> AsExpression<T::SqlType> for T type Expression = Self;
[src]
impl<'expr> AsExpression<Timestamp> for &'expr PgTimestamp type Expression = Bound<Timestamp, Self>;
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr PgTimestamp type Expression = Bound<Nullable<Timestamp>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr PgTimestamp type Expression = Bound<Timestamp, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr PgTimestamp type Expression = Bound<Nullable<Timestamp>, Self>;
[src]
impl AsExpression<Timestamp> for PgTimestamp type Expression = Bound<Timestamp, Self>;
[src]
impl AsExpression<Nullable<Timestamp>> for PgTimestamp type Expression = Bound<Nullable<Timestamp>, Self>;
[src]
impl<'expr> AsExpression<Timestamptz> for &'expr PgTimestamp type Expression = Bound<Timestamptz, Self>;
[src]
impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr PgTimestamp type Expression = Bound<Nullable<Timestamptz>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Timestamptz> for &'expr2 &'expr PgTimestamp type Expression = Bound<Timestamptz, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr PgTimestamp type Expression = Bound<Nullable<Timestamptz>, Self>;
[src]
impl AsExpression<Timestamptz> for PgTimestamp type Expression = Bound<Timestamptz, Self>;
[src]
impl AsExpression<Nullable<Timestamptz>> for PgTimestamp type Expression = Bound<Nullable<Timestamptz>, Self>;
[src]
impl<'expr> AsExpression<Date> for &'expr PgDate type Expression = Bound<Date, Self>;
[src]
impl<'expr> AsExpression<Nullable<Date>> for &'expr PgDate type Expression = Bound<Nullable<Date>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr PgDate type Expression = Bound<Date, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr PgDate type Expression = Bound<Nullable<Date>, Self>;
[src]
impl AsExpression<Date> for PgDate type Expression = Bound<Date, Self>;
[src]
impl AsExpression<Nullable<Date>> for PgDate type Expression = Bound<Nullable<Date>, Self>;
[src]
impl<'expr> AsExpression<Time> for &'expr PgTime type Expression = Bound<Time, Self>;
[src]
impl<'expr> AsExpression<Nullable<Time>> for &'expr PgTime type Expression = Bound<Nullable<Time>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr PgTime type Expression = Bound<Time, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr PgTime type Expression = Bound<Nullable<Time>, Self>;
[src]
impl AsExpression<Time> for PgTime type Expression = Bound<Time, Self>;
[src]
impl AsExpression<Nullable<Time>> for PgTime type Expression = Bound<Nullable<Time>, Self>;
[src]
impl<'expr> AsExpression<Interval> for &'expr PgInterval type Expression = Bound<Interval, Self>;
[src]
impl<'expr> AsExpression<Nullable<Interval>> for &'expr PgInterval type Expression = Bound<Nullable<Interval>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Interval> for &'expr2 &'expr PgInterval type Expression = Bound<Interval, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Interval>> for &'expr2 &'expr PgInterval type Expression = Bound<Nullable<Interval>, Self>;
[src]
impl AsExpression<Interval> for PgInterval type Expression = Bound<Interval, Self>;
[src]
impl AsExpression<Nullable<Interval>> for PgInterval type Expression = Bound<Nullable<Interval>, Self>;
[src]
impl<'expr> AsExpression<Numeric> for &'expr PgNumeric type Expression = Bound<Numeric, Self>;
[src]
impl<'expr> AsExpression<Nullable<Numeric>> for &'expr PgNumeric type Expression = Bound<Nullable<Numeric>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Numeric> for &'expr2 &'expr PgNumeric type Expression = Bound<Numeric, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Numeric>> for &'expr2 &'expr PgNumeric type Expression = Bound<Nullable<Numeric>, Self>;
[src]
impl AsExpression<Numeric> for PgNumeric type Expression = Bound<Numeric, Self>;
[src]
impl AsExpression<Nullable<Numeric>> for PgNumeric type Expression = Bound<Nullable<Numeric>, Self>;
[src]
impl<'expr> AsExpression<Money> for &'expr PgMoney type Expression = Bound<Money, Self>;
[src]
impl<'expr> AsExpression<Nullable<Money>> for &'expr PgMoney type Expression = Bound<Nullable<Money>, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Money> for &'expr2 &'expr PgMoney type Expression = Bound<Money, Self>;
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Money>> for &'expr2 &'expr PgMoney type Expression = Bound<Nullable<Money>, Self>;
[src]
impl AsExpression<Money> for PgMoney type Expression = Bound<Money, Self>;
[src]
impl AsExpression<Nullable<Money>> for PgMoney type Expression = Bound<Nullable<Money>, Self>;
[src]