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

pub trait AsExpression<T> where
    T: SqlType + TypedExpressionType, {
    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.

This trait could be derived

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

`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<'expr> AsExpression<MacAddr> for &'expr [u8; 6]`[src]

`type Expression = Bound<MacAddr, Self>`

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

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

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

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

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

`type Expression = Bound<MacAddr, Self>`

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

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

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

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

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

`type Expression = Bound<MacAddr, Self>`

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

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

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

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

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

`type Expression = Bound<Inet, Self>`

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

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

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

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

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

`type Expression = Bound<Inet, Self>`

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

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

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

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

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

`type Expression = Bound<Inet, Self>`

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

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

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

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

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

`type Expression = Bound<Cidr, Self>`

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

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

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

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

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

`type Expression = Bound<Cidr, Self>`

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

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

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

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

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

`type Expression = Bound<Cidr, Self>`

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

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

`type Expression = Bound<Nullable<Cidr>, 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 SA: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, SAB: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, SAB: SqlType + TypedExpressionType, SAC: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, SAB: SqlType + TypedExpressionType, SAC: SqlType + TypedExpressionType, SAD: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, SAB: SqlType + TypedExpressionType, SAC: SqlType + TypedExpressionType, SAD: SqlType + TypedExpressionType, SAE: SqlType + TypedExpressionType, 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 SA: SqlType + TypedExpressionType, SB: SqlType + TypedExpressionType, SC: SqlType + TypedExpressionType, SD: SqlType + TypedExpressionType, SE: SqlType + TypedExpressionType, SF: SqlType + TypedExpressionType, SG: SqlType + TypedExpressionType, SH: SqlType + TypedExpressionType, SI: SqlType + TypedExpressionType, SJ: SqlType + TypedExpressionType, SK: SqlType + TypedExpressionType, SL: SqlType + TypedExpressionType, SM: SqlType + TypedExpressionType, SN: SqlType + TypedExpressionType, SO: SqlType + TypedExpressionType, SP: SqlType + TypedExpressionType, SQ: SqlType + TypedExpressionType, SR: SqlType + TypedExpressionType, SS: SqlType + TypedExpressionType, ST: SqlType + TypedExpressionType, SU: SqlType + TypedExpressionType, SV: SqlType + TypedExpressionType, SW: SqlType + TypedExpressionType, SX: SqlType + TypedExpressionType, SY: SqlType + TypedExpressionType, SZ: SqlType + TypedExpressionType, SAA: SqlType + TypedExpressionType, SAB: SqlType + TypedExpressionType, SAC: SqlType + TypedExpressionType, SAD: SqlType + TypedExpressionType, SAE: SqlType + TypedExpressionType, SAF: SqlType + TypedExpressionType, 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<Uuid> for &'expr Uuid`[src]

`type Expression = Bound<Uuid, Self>`

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

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

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

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

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

`type Expression = Bound<Uuid, Self>`

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

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

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

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

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

`type Expression = Bound<Uuid, Self>`

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

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

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

`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<'expr> AsExpression<Numeric> for &'expr BigDecimal`[src]

`type Expression = Bound<Numeric, Self>`

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

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

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

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

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

`type Expression = Bound<Numeric, Self>`

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

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

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

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

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

`type Expression = Bound<Numeric, Self>`

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

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

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

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

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

`type Expression = Bound<Json, Self>`

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

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

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

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

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

`type Expression = Bound<Json, Self>`

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

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

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

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

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

`type Expression = Bound<Json, Self>`

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

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

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

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

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

`type Expression = Bound<Jsonb, Self>`

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

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

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

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

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

`type Expression = Bound<Jsonb, Self>`

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

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

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

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

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

`type Expression = Bound<Jsonb, Self>`

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

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

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

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

`impl<T, ST> AsExpression<ST> for Option<T> where ST: SqlType<IsNull = IsNullable> + SingleValue,` [src]

`type Expression = Bound<ST, Self>`

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

`impl<'a, T, ST> AsExpression<Nullable<ST>> for &'a Option<T> where ST: SqlType<IsNull = NotNull>, Nullable<ST>: TypedExpressionType,` [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<TinyInt>> for &'expr u8`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type Expression = Bound<Nullable<Unsigned<TinyInt>>, 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>, ST: SqlType + TypedExpressionType,` [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>, ST: SqlType + TypedExpressionType,` [src]

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

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

Loading content...

Implementors

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

`type Expression = Bound<Money, Self>`

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

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

`type Expression = Coerce<now, Timestamptz>`

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

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

`type Expression = Bound<Timestamptz, Self>`

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

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

`type Expression = Bound<Date, Self>`

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

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

`type Expression = Bound<Interval, Self>`

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

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

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

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

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

`type Expression = Coerce<now, Nullable<Timestamptz>>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type Expression = Bound<Numeric, Self>`

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

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

`type Expression = Bound<Time, Self>`

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

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

`type Expression = Bound<Timestamp, Self>`

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

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

`type Expression = Bound<Money, Self>`

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

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

`type Expression = Bound<Timestamptz, Self>`

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

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

`type Expression = Bound<Date, Self>`

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

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

`type Expression = Bound<Interval, Self>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type Expression = Bound<Numeric, Self>`

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

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

`type Expression = Bound<Time, Self>`

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

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

`type Expression = Bound<Timestamp, Self>`

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

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

`type Expression = Bound<Money, Self>`

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

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

`type Expression = Bound<Timestamptz, Self>`

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

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

`type Expression = Bound<Date, Self>`

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

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

`type Expression = Bound<Interval, Self>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type Expression = Bound<Numeric, Self>`

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

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

`type Expression = Bound<Time, Self>`

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

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

`type Expression = Bound<Timestamp, Self>`

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

`impl<T, ST> AsExpression<ST> for T where ST: SqlType + IntoNotNullable + TypedExpressionType, ST::NotNullable: SingleValue, ExpressionImplHelper<T, ST::IsNull, <T::SqlType as SqlType>::IsNull>: AsExpressionHelper<ST>, T: Expression, T::SqlType: SqlType,` [src]

`type Expression = <ExpressionImplHelper<T, ST::IsNull, <T::SqlType as SqlType>::IsNull> as AsExpressionHelper<ST>>::Expression`

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

Loading content...