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

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:

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:

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

Loading content...

Required methods

fn as_expression(self) -> Self::Expression

Perform the conversion

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

impl AsExpression<Timestamp> for Timespec[src]

type Expression = Bound<Timestamp, Self>

impl AsExpression<Nullable<Timestamp>> for Timespec[src]

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

impl<'expr> AsExpression<Json> for &'expr Value[src]

type Expression = Bound<Json, Self>

impl<'expr> AsExpression<Nullable<Json>> for &'expr Value[src]

type Expression = Bound<Nullable<Json>, Self>

impl<'expr2, 'expr> AsExpression<Json> for &'expr2 &'expr Value[src]

type Expression = Bound<Json, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Json>> for &'expr2 &'expr Value[src]

type Expression = Bound<Nullable<Json>, Self>

impl AsExpression<Json> for Value[src]

type Expression = Bound<Json, Self>

impl AsExpression<Nullable<Json>> for Value[src]

type Expression = Bound<Nullable<Json>, Self>

impl<'expr> AsExpression<Jsonb> for &'expr Value[src]

type Expression = Bound<Jsonb, Self>

impl<'expr> AsExpression<Nullable<Jsonb>> for &'expr Value[src]

type Expression = Bound<Nullable<Jsonb>, Self>

impl<'expr2, 'expr> AsExpression<Jsonb> for &'expr2 &'expr Value[src]

type Expression = Bound<Jsonb, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Jsonb>> for &'expr2 &'expr Value[src]

type Expression = Bound<Nullable<Jsonb>, Self>

impl AsExpression<Jsonb> for Value[src]

type Expression = Bound<Jsonb, Self>

impl AsExpression<Nullable<Jsonb>> for Value[src]

type Expression = Bound<Nullable<Jsonb>, Self>

impl<'expr> AsExpression<MacAddr> for &'expr [u8; 6][src]

type Expression = Bound<MacAddr, Self>

impl<'expr> AsExpression<Nullable<MacAddr>> for &'expr [u8; 6][src]

type Expression = Bound<Nullable<MacAddr>, Self>

impl<'expr2, 'expr> AsExpression<MacAddr> for &'expr2 &'expr [u8; 6][src]

type Expression = Bound<MacAddr, Self>

impl<'expr2, 'expr> AsExpression<Nullable<MacAddr>> for &'expr2 &'expr [u8; 6][src]

type Expression = Bound<Nullable<MacAddr>, Self>

impl AsExpression<MacAddr> for [u8; 6][src]

type Expression = Bound<MacAddr, Self>

impl AsExpression<Nullable<MacAddr>> for [u8; 6][src]

type Expression = Bound<Nullable<MacAddr>, Self>

impl<'expr> AsExpression<Inet> for &'expr IpNetwork[src]

type Expression = Bound<Inet, Self>

impl<'expr> AsExpression<Nullable<Inet>> for &'expr IpNetwork[src]

type Expression = Bound<Nullable<Inet>, Self>

impl<'expr2, 'expr> AsExpression<Inet> for &'expr2 &'expr IpNetwork[src]

type Expression = Bound<Inet, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Inet>> for &'expr2 &'expr IpNetwork[src]

type Expression = Bound<Nullable<Inet>, Self>

impl AsExpression<Inet> for IpNetwork[src]

type Expression = Bound<Inet, Self>

impl AsExpression<Nullable<Inet>> for IpNetwork[src]

type Expression = Bound<Nullable<Inet>, Self>

impl<'expr> AsExpression<Cidr> for &'expr IpNetwork[src]

type Expression = Bound<Cidr, Self>

impl<'expr> AsExpression<Nullable<Cidr>> for &'expr IpNetwork[src]

type Expression = Bound<Nullable<Cidr>, Self>

impl<'expr2, 'expr> AsExpression<Cidr> for &'expr2 &'expr IpNetwork[src]

type Expression = Bound<Cidr, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Cidr>> for &'expr2 &'expr IpNetwork[src]

type Expression = Bound<Nullable<Cidr>, Self>

impl AsExpression<Cidr> for IpNetwork[src]

type Expression = Bound<Cidr, Self>

impl AsExpression<Nullable<Cidr>> for IpNetwork[src]

type Expression = Bound<Nullable<Cidr>, Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'expr> AsExpression<Uuid> for &'expr Uuid[src]

type Expression = Bound<Uuid, Self>

impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid[src]

type Expression = Bound<Nullable<Uuid>, Self>

impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid[src]

type Expression = Bound<Uuid, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Uuid>> for &'expr2 &'expr Uuid[src]

type Expression = Bound<Nullable<Uuid>, Self>

impl AsExpression<Uuid> for Uuid[src]

type Expression = Bound<Uuid, Self>

impl AsExpression<Nullable<Uuid>> for Uuid[src]

type Expression = Bound<Nullable<Uuid>, Self>

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

impl AsExpression<Timestamp> for SystemTime[src]

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

impl AsExpression<Date> for NaiveDate[src]

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

impl AsExpression<Time> for NaiveTime[src]

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

impl AsExpression<Timestamp> for NaiveDateTime[src]

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamptz, Self>

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

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

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

type Expression = Bound<Timestamptz, Self>

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

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

impl AsExpression<Timestamptz> for NaiveDateTime[src]

type Expression = Bound<Timestamptz, Self>

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

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

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

type Expression = Bound<Datetime, Self>

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

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

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

type Expression = Bound<Datetime, Self>

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

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

impl AsExpression<Datetime> for NaiveDateTime[src]

type Expression = Bound<Datetime, Self>

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

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

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

type Expression = Bound<Timestamptz, Self>

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

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

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

type Expression = Bound<Timestamptz, Self>

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

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

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

type Expression = Bound<Timestamptz, Self>

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

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

impl<'expr> AsExpression<Numeric> for &'expr BigDecimal[src]

type Expression = Bound<Numeric, Self>

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr BigDecimal[src]

type Expression = Bound<Nullable<Numeric>, Self>

impl<'expr2, 'expr> AsExpression<Numeric> for &'expr2 &'expr BigDecimal[src]

type Expression = Bound<Numeric, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Numeric>> for &'expr2 &'expr BigDecimal[src]

type Expression = Bound<Nullable<Numeric>, Self>

impl AsExpression<Numeric> for BigDecimal[src]

type Expression = Bound<Numeric, Self>

impl AsExpression<Nullable<Numeric>> for BigDecimal[src]

type Expression = Bound<Nullable<Numeric>, Self>

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

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

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

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

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

type Expression = Bound<Bool, Self>

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

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

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

type Expression = Bound<Bool, Self>

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

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

impl AsExpression<Bool> for bool[src]

type Expression = Bound<Bool, Self>

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

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

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

type Expression = Bound<TinyInt, Self>

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

type Expression = Bound<Nullable<TinyInt>, Self>

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

type Expression = Bound<TinyInt, Self>

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

type Expression = Bound<Nullable<TinyInt>, Self>

impl AsExpression<TinyInt> for i8[src]

type Expression = Bound<TinyInt, Self>

impl AsExpression<Nullable<TinyInt>> for i8[src]

type Expression = Bound<Nullable<TinyInt>, Self>

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

type Expression = Bound<SmallInt, Self>

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

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

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

type Expression = Bound<SmallInt, Self>

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

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

impl AsExpression<SmallInt> for i16[src]

type Expression = Bound<SmallInt, Self>

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

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

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

type Expression = Bound<Integer, Self>

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

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

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

type Expression = Bound<Integer, Self>

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

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

impl AsExpression<Integer> for i32[src]

type Expression = Bound<Integer, Self>

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

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

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

type Expression = Bound<BigInt, Self>

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

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

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

type Expression = Bound<BigInt, Self>

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

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

impl AsExpression<BigInt> for i64[src]

type Expression = Bound<BigInt, Self>

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

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

impl<'expr> AsExpression<Unsigned<TinyInt>> for &'expr u8[src]

type Expression = Bound<Unsigned<TinyInt>, Self>

impl<'expr> AsExpression<Nullable<Unsigned<TinyInt>>> for &'expr u8[src]

type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>

impl<'expr2, 'expr> AsExpression<Unsigned<TinyInt>> for &'expr2 &'expr u8[src]

type Expression = Bound<Unsigned<TinyInt>, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<TinyInt>>> for &'expr2 &'expr u8[src]

type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>

impl AsExpression<Unsigned<TinyInt>> for u8[src]

type Expression = Bound<Unsigned<TinyInt>, Self>

impl AsExpression<Nullable<Unsigned<TinyInt>>> for u8[src]

type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Expression = Bound<Oid, Self>

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

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

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

type Expression = Bound<Oid, Self>

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

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

impl AsExpression<Oid> for u32[src]

type Expression = Bound<Oid, Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Expression = Bound<Float, Self>

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

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

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

type Expression = Bound<Float, Self>

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

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

impl AsExpression<Float> for f32[src]

type Expression = Bound<Float, Self>

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

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

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

type Expression = Bound<Double, Self>

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

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

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

type Expression = Bound<Double, Self>

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

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

impl AsExpression<Double> for f64[src]

type Expression = Bound<Double, Self>

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

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

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

type Expression = Bound<Text, Self>

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

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

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

type Expression = Bound<Text, Self>

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

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

impl AsExpression<Text> for String[src]

type Expression = Bound<Text, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

impl AsExpression<Date> for String[src]

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

impl AsExpression<Time> for String[src]

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

impl AsExpression<Timestamp> for String[src]

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Text, Self>

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

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

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

type Expression = Bound<Text, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Date, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Time, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Timestamp, Self>

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

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

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

type Expression = Bound<Binary, Self>

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

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

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

type Expression = Bound<Binary, Self>

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

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

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

type Expression = Bound<Binary, Self>

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

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

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

type Expression = Bound<Binary, Self>

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

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

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

type Expression = Bound<Binary, Self>

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

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

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>

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>

Loading content...

Implementors

impl AsExpression<Money> for PgMoney[src]

type Expression = Bound<Money, Self>

impl AsExpression<Timestamptz> for now[src]

type Expression = Coerce<now, Timestamptz>

impl AsExpression<Timestamptz> for PgTimestamp[src]

type Expression = Bound<Timestamptz, Self>

impl AsExpression<Date> for PgDate[src]

type Expression = Bound<Date, Self>

impl AsExpression<Interval> for PgInterval[src]

type Expression = Bound<Interval, Self>

impl AsExpression<Nullable<Money>> for PgMoney[src]

type Expression = Bound<Nullable<Money>, Self>

impl AsExpression<Nullable<Timestamptz>> for now[src]

impl AsExpression<Nullable<Timestamptz>> for PgTimestamp[src]

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

impl AsExpression<Nullable<Date>> for PgDate[src]

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

impl AsExpression<Nullable<Interval>> for PgInterval[src]

type Expression = Bound<Nullable<Interval>, Self>

impl AsExpression<Nullable<Numeric>> for PgNumeric[src]

type Expression = Bound<Nullable<Numeric>, Self>

impl AsExpression<Nullable<Time>> for PgTime[src]

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

impl AsExpression<Nullable<Timestamp>> for now[src]

type Expression = Coerce<now, Nullable<Timestamp>>

impl AsExpression<Nullable<Timestamp>> for PgTimestamp[src]

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

impl AsExpression<Numeric> for PgNumeric[src]

type Expression = Bound<Numeric, Self>

impl AsExpression<Time> for PgTime[src]

type Expression = Bound<Time, Self>

impl AsExpression<Timestamp> for PgTimestamp[src]

type Expression = Bound<Timestamp, Self>

impl<'expr> AsExpression<Money> for &'expr PgMoney[src]

type Expression = Bound<Money, Self>

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

type Expression = Bound<Timestamptz, Self>

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

type Expression = Bound<Date, Self>

impl<'expr> AsExpression<Interval> for &'expr PgInterval[src]

type Expression = Bound<Interval, Self>

impl<'expr> AsExpression<Nullable<Money>> for &'expr PgMoney[src]

type Expression = Bound<Nullable<Money>, Self>

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

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

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

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

impl<'expr> AsExpression<Nullable<Interval>> for &'expr PgInterval[src]

type Expression = Bound<Nullable<Interval>, Self>

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr PgNumeric[src]

type Expression = Bound<Nullable<Numeric>, Self>

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

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

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

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

impl<'expr> AsExpression<Numeric> for &'expr PgNumeric[src]

type Expression = Bound<Numeric, Self>

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

type Expression = Bound<Time, Self>

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

type Expression = Bound<Timestamp, Self>

impl<'expr2, 'expr> AsExpression<Money> for &'expr2 &'expr PgMoney[src]

type Expression = Bound<Money, Self>

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

type Expression = Bound<Timestamptz, Self>

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

type Expression = Bound<Date, Self>

impl<'expr2, 'expr> AsExpression<Interval> for &'expr2 &'expr PgInterval[src]

type Expression = Bound<Interval, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Money>> for &'expr2 &'expr PgMoney[src]

type Expression = Bound<Nullable<Money>, Self>

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

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

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

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

impl<'expr2, 'expr> AsExpression<Nullable<Interval>> for &'expr2 &'expr PgInterval[src]

type Expression = Bound<Nullable<Interval>, Self>

impl<'expr2, 'expr> AsExpression<Nullable<Numeric>> for &'expr2 &'expr PgNumeric[src]

type Expression = Bound<Nullable<Numeric>, Self>

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

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

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

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

impl<'expr2, 'expr> AsExpression<Numeric> for &'expr2 &'expr PgNumeric[src]

type Expression = Bound<Numeric, Self>

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

type Expression = Bound<Time, Self>

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

type Expression = Bound<Timestamp, Self>

impl<T: Expression> AsExpression<<T as Expression>::SqlType> for T[src]

type Expression = Self

Loading content...