Trait block_tools::db::use_diesel::expression::AsExpression[−][src]

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

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

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

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

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

Deriving

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

This will generate the following impls:

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

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

Associated Types

`type Expression: Expression`[src]

The expression being returned

Loading content...

Required methods

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

Perform the conversion

Loading content...

Implementations on Foreign Types

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

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, &'expr [u8]>`

`pub fn as_expression( self ) -> <&'expr [u8] as AsExpression<Nullable<Binary>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, B: AsExpression<SB>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>>>::Expression`[src]

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

`type Expression = Bound<Integer, &'expr2 &'expr i32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i32 as AsExpression<Integer>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr2 &'expr SystemTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr SystemTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <bool as AsExpression<Nullable<Bool>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a &'b [T]>`

`pub fn as_expression( self ) -> <&'a &'b [T] as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <(A, B) as AsExpression<Record<(SA, SB)>>>::Expression`[src]

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

`type Expression = Bound<Time, &'expr NaiveTime>`

`pub fn as_expression( self ) -> <&'expr NaiveTime as AsExpression<Time>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <i64 as AsExpression<Nullable<BigInt>>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr2 &'expr [u8]>`

`pub fn as_expression( self ) -> <&'expr2 &'expr [u8] as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Timestamp, SystemTime>`

`pub fn as_expression( self ) -> <SystemTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr2 &'expr Vec<u8, Global>>`

`pub fn as_expression( self ) -> <&'expr2 &'expr Vec<u8, Global> as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Nullable<Double>, &'expr f64>`

`pub fn as_expression( self ) -> <&'expr f64 as AsExpression<Nullable<Double>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <i16 as AsExpression<Nullable<SmallInt>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Double, &'expr f64>`

`pub fn as_expression(self) -> <&'expr f64 as AsExpression<Double>>::Expression`[src]

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

`type Expression = Bound<Timestamp, NaiveDateTime>`

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Bool, bool>`

`pub fn as_expression(self) -> <bool as AsExpression<Bool>>::Expression`[src]

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

`type Expression = Bound<Double, &'expr2 &'expr f64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr f64 as AsExpression<Double>>::Expression`[src]

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

`type Expression = Bound<BigInt, &'expr2 &'expr i64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i64 as AsExpression<BigInt>>::Expression`[src]

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

`type Expression = Bound<Text, &'expr2 &'expr str>`

`pub fn as_expression( self ) -> <&'expr2 &'expr str as AsExpression<Text>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a [T]>`

`pub fn as_expression( self ) -> <&'a [T] as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, &'a &'b [T]>`

`pub fn as_expression( self ) -> <&'a &'b [T] as AsExpression<Array<ST>>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, DateTime<Tz>>`

`pub fn as_expression( self ) -> <DateTime<Tz> as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<BigInt, &'expr i64>`

`pub fn as_expression(self) -> <&'expr i64 as AsExpression<BigInt>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <f64 as AsExpression<Nullable<Double>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Bool>, &'expr2 &'expr bool>`

`pub fn as_expression( self ) -> <&'expr2 &'expr bool as AsExpression<Nullable<Bool>>>::Expression`[src]

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

`type Expression = Bound<SmallInt, i16>`

`pub fn as_expression(self) -> <i16 as AsExpression<SmallInt>>::Expression`[src]

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

`type Expression = Bound<Nullable<Time>, &'expr2 &'expr NaiveTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, &'expr Vec<u8, Global>>`

`pub fn as_expression( self ) -> <&'expr Vec<u8, Global> as AsExpression<Nullable<Binary>>>::Expression`[src]

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

`type Expression = Bound<Binary, Vec<u8, Global>>`

`pub fn as_expression( self ) -> <Vec<u8, Global> as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, NaiveDateTime>`

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Range<ST>, &'a (Bound<T>, Bound<T>)>`

`pub fn as_expression( self ) -> <&'a (Bound<T>, Bound<T>) as AsExpression<Range<ST>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression)>

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

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

`type Expression = Bound<Nullable<Double>, &'expr2 &'expr f64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr f64 as AsExpression<Nullable<Double>>>::Expression`[src]

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

`type Expression = Bound<Time, NaiveTime>`

`pub fn as_expression(self) -> <NaiveTime as AsExpression<Time>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<ST, Cow<'a, T>>`

`pub fn as_expression(self) -> <Cow<'a, T> as AsExpression<ST>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr2 &'expr DateTime<Tz>>`

`pub fn as_expression( self ) -> <&'expr2 &'expr DateTime<Tz> as AsExpression<Timestamptz>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, [src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, Vec<T, Global>>`

`pub fn as_expression( self ) -> <Vec<T, Global> as AsExpression<Array<ST>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>>::Expression`[src]

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

`type Expression = Bound<Date, &'expr2 &'expr NaiveDate>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDate as AsExpression<Date>>::Expression`[src]

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

`type Expression = Bound<Nullable<Range<ST>>, &'a (Bound<T>, Bound<T>)>`

`pub fn as_expression( self ) -> <&'a (Bound<T>, Bound<T>) as AsExpression<Nullable<Range<ST>>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr SystemTime>`

`pub fn as_expression( self ) -> <&'expr SystemTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Text, &'expr2 &'expr String>`

`pub fn as_expression( self ) -> <&'expr2 &'expr String as AsExpression<Text>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, Vec<T, Global>>`

`pub fn as_expression( self ) -> <Vec<T, Global> as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr DateTime<Tz>>`

`pub fn as_expression( self ) -> <&'expr DateTime<Tz> as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Nullable<Oid>, &'expr2 &'expr u32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr u32 as AsExpression<Nullable<Oid>>>::Expression`[src]

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

`type Expression = Bound<Float, &'expr2 &'expr f32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr f32 as AsExpression<Float>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <NaiveTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

`type Expression = Bound<Nullable<BigInt>, &'expr i64>`

`pub fn as_expression( self ) -> <&'expr i64 as AsExpression<Nullable<BigInt>>>::Expression`[src]

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

`type Expression = Bound<Text, &'expr String>`

`pub fn as_expression(self) -> <&'expr String as AsExpression<Text>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr SystemTime>`

`pub fn as_expression( self ) -> <&'expr SystemTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Nullable<Float>, &'expr f32>`

`pub fn as_expression( self ) -> <&'expr f32 as AsExpression<Nullable<Float>>>::Expression`[src]

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

`type Expression = Bound<Text, &'expr str>`

`pub fn as_expression(self) -> <&'expr str as AsExpression<Text>>::Expression`[src]

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

`type Expression = Bound<Nullable<BigInt>, &'expr2 &'expr i64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i64 as AsExpression<Nullable<BigInt>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr NaiveDateTime as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Text>, &'expr str>`

`pub fn as_expression( self ) -> <&'expr str as AsExpression<Nullable<Text>>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr [u8]>`

`pub fn as_expression(self) -> <&'expr [u8] as AsExpression<Binary>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <f32 as AsExpression<Nullable<Float>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Range<ST>>, (Bound<T>, Bound<T>)>`

`pub fn as_expression( self ) -> <(Bound<T>, Bound<T>) as AsExpression<Nullable<Range<ST>>>>::Expression`[src]

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

`type Expression = Bound<Date, &'expr NaiveDate>`

`pub fn as_expression( self ) -> <&'expr NaiveDate as AsExpression<Date>>::Expression`[src]

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

`type Expression = Bound<Nullable<ST>, &'a Option<T>>`

`pub fn as_expression( self ) -> <&'a Option<T> as AsExpression<Nullable<ST>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, Vec<u8, Global>>`

`pub fn as_expression( self ) -> <Vec<u8, Global> as AsExpression<Nullable<Binary>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Time>, &'expr NaiveTime>`

`pub fn as_expression( self ) -> <&'expr NaiveTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr SystemTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr SystemTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a &'b Vec<T, Global>>`

`pub fn as_expression( self ) -> <&'a &'b Vec<T, Global> as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

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

`type Expression = Bound<Float, &'expr f32>`

`pub fn as_expression(self) -> <&'expr f32 as AsExpression<Float>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr Vec<u8, Global>>`

`pub fn as_expression( self ) -> <&'expr Vec<u8, Global> as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr NaiveDateTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Oid>, &'expr u32>`

`pub fn as_expression( self ) -> <&'expr u32 as AsExpression<Nullable<Oid>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Text>, &'expr2 &'expr str>`

`pub fn as_expression( self ) -> <&'expr2 &'expr str as AsExpression<Nullable<Text>>>::Expression`[src]

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

`type Expression = Bound<Bool, &'expr2 &'expr bool>`

`pub fn as_expression( self ) -> <&'expr2 &'expr bool as AsExpression<Bool>>::Expression`[src]

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

`type Expression = Bound<Double, f64>`

`pub fn as_expression(self) -> <f64 as AsExpression<Double>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr NaiveDateTime as AsExpression<Timestamptz>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression)>

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

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

`type Expression = Bound<Nullable<SmallInt>, &'expr i16>`

`pub fn as_expression( self ) -> <&'expr i16 as AsExpression<Nullable<SmallInt>>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <u32 as AsExpression<Nullable<Oid>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Date>, &'expr2 &'expr NaiveDate>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDate as AsExpression<Nullable<Date>>>::Expression`[src]

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

`type Expression = Bound<Nullable<ST>, Option<T>>`

`pub fn as_expression( self ) -> <Option<T> as AsExpression<Nullable<ST>>>::Expression`[src]

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

`type Expression = Bound<Range<ST>, (Bound<T>, Bound<T>)>`

`pub fn as_expression( self ) -> <(Bound<T>, Bound<T>) as AsExpression<Range<ST>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, DateTime<Tz>>`

`pub fn as_expression( self ) -> <DateTime<Tz> as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Oid, &'expr2 &'expr u32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr u32 as AsExpression<Oid>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, &'a Vec<T, Global>>`

`pub fn as_expression( self ) -> <&'a Vec<T, Global> as AsExpression<Array<ST>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Bool>, &'expr bool>`

`pub fn as_expression( self ) -> <&'expr bool as AsExpression<Nullable<Bool>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, AB: AsExpression<SAB>, AC: AsExpression<SAC>, AD: AsExpression<SAD>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Float>, &'expr2 &'expr f32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr f32 as AsExpression<Nullable<Float>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr2 &'expr DateTime<Tz>>`

`pub fn as_expression( self ) -> <&'expr2 &'expr DateTime<Tz> as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C) as AsExpression<Record<(SA, SB, SC)>>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, &'a &'b Vec<T, Global>>`

`pub fn as_expression( self ) -> <&'a &'b Vec<T, Global> as AsExpression<Array<ST>>>::Expression`[src]

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

`type Expression = Bound<Integer, &'expr i32>`

`pub fn as_expression(self) -> <&'expr i32 as AsExpression<Integer>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, &'expr2 &'expr [u8]>`

`pub fn as_expression( self ) -> <&'expr2 &'expr [u8] as AsExpression<Nullable<Binary>>>::Expression`[src]

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

`type Expression = Bound<SmallInt, &'expr2 &'expr i16>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i16 as AsExpression<SmallInt>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr DateTime<Tz>>`

`pub fn as_expression( self ) -> <&'expr DateTime<Tz> as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr NaiveDateTime as AsExpression<Nullable<Timestamp>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression, <AF as AsExpression<SAF>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression, <AF as AsExpression<SAF>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression, <AF as AsExpression<SAF>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, [src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as 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)>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, [src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Text>, &'expr String>`

`pub fn as_expression( self ) -> <&'expr String as AsExpression<Nullable<Text>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, I: AsExpression<SI>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Text>, &'expr2 &'expr String>`

`pub fn as_expression( self ) -> <&'expr2 &'expr String as AsExpression<Nullable<Text>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<SmallInt>, &'expr2 &'expr i16>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i16 as AsExpression<Nullable<SmallInt>>>::Expression`[src]

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

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D) as AsExpression<Record<(SA, SB, SC, SD)>>>::Expression`[src]

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

`type Expression = Bound<Integer, i32>`

`pub fn as_expression(self) -> <i32 as AsExpression<Integer>>::Expression`[src]

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

`type Expression = Bound<Oid, u32>`

`pub fn as_expression(self) -> <u32 as AsExpression<Oid>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, &'expr2 &'expr Vec<u8, Global>>`

`pub fn as_expression( self ) -> <&'expr2 &'expr Vec<u8, Global> as AsExpression<Nullable<Binary>>>::Expression`[src]

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

`type Expression = Bound<Text, String>`

`pub fn as_expression(self) -> <String as AsExpression<Text>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, Y: AsExpression<SY>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a Vec<T, Global>>`

`pub fn as_expression( self ) -> <&'a Vec<T, Global> as AsExpression<Nullable<Array<ST>>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, P: AsExpression<SP>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, [src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>>::Expression`[src]

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

`type Expression = Bound<Oid, &'expr u32>`

`pub fn as_expression(self) -> <&'expr u32 as AsExpression<Oid>>::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 C: AsExpression<SC>, D: AsExpression<SD>, E: AsExpression<SE>, A: AsExpression<SA>, B: AsExpression<SB>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E) as AsExpression<Record<(SA, SB, SC, SD, SE)>>>::Expression`[src]

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

`type Expression = Bound<Time, &'expr2 &'expr NaiveTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveTime as AsExpression<Time>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Integer>, &'expr i32>`

`pub fn as_expression( self ) -> <&'expr i32 as AsExpression<Nullable<Integer>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, B: AsExpression<SB>, H: AsExpression<SH>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, AA: AsExpression<SAA>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<BigInt, i64>`

`pub fn as_expression(self) -> <i64 as AsExpression<BigInt>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <i32 as AsExpression<Nullable<Integer>>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <(A,) as AsExpression<Record<(SA,)>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, L: AsExpression<SL>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, &'a [T]>`

`pub fn as_expression(self) -> <&'a [T] as AsExpression<Array<ST>>>::Expression`[src]

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

`type Expression = Bound<Bool, &'expr bool>`

`pub fn as_expression(self) -> <&'expr bool as AsExpression<Bool>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression)>

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

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

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

`pub fn as_expression( self ) -> <SystemTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <NaiveDate as AsExpression<Nullable<Date>>>::Expression`[src]

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

`type Expression = Bound<Date, NaiveDate>`

`pub fn as_expression(self) -> <NaiveDate as AsExpression<Date>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <&'b Cow<'a, T> as AsExpression<ST>>::Expression`[src]

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

`type Expression = Bound<Float, f32>`

`pub fn as_expression(self) -> <f32 as AsExpression<Float>>::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 C: AsExpression<SC>, S: AsExpression<SS>, F: AsExpression<SF>, D: AsExpression<SD>, W: AsExpression<SW>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, T: AsExpression<ST>, M: AsExpression<SM>, E: AsExpression<SE>, U: AsExpression<SU>, P: AsExpression<SP>, A: AsExpression<SA>, R: AsExpression<SR>, K: AsExpression<SK>, V: AsExpression<SV>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, X: AsExpression<SX>, Y: AsExpression<SY>, Z: AsExpression<SZ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression)>

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <String as AsExpression<Nullable<Text>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, G: AsExpression<SG>, E: AsExpression<SE>, A: AsExpression<SA>, I: AsExpression<SI>, B: AsExpression<SB>, H: AsExpression<SH>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, O: AsExpression<SO>, L: AsExpression<SL>, G: AsExpression<SG>, M: AsExpression<SM>, E: AsExpression<SE>, P: AsExpression<SP>, A: AsExpression<SA>, K: AsExpression<SK>, I: AsExpression<SI>, N: AsExpression<SN>, B: AsExpression<SB>, H: AsExpression<SH>, J: AsExpression<SJ>, Q: AsExpression<SQ>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression)> as 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 as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression)>

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>>::Expression`[src]

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

`type Expression = Bound<SmallInt, &'expr i16>`

`pub fn as_expression(self) -> <&'expr i16 as AsExpression<SmallInt>>::Expression`[src]

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

`type Expression = Bound<Nullable<Integer>, &'expr2 &'expr i32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i32 as AsExpression<Nullable<Integer>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Date>, &'expr NaiveDate>`

`pub fn as_expression( self ) -> <&'expr NaiveDate as AsExpression<Nullable<Date>>>::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 C: AsExpression<SC>, F: AsExpression<SF>, D: AsExpression<SD>, E: AsExpression<SE>, A: AsExpression<SA>, B: AsExpression<SB>, PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression)>: Expression, <PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression)> as Expression>::SqlType == Record<(SA, SB, SC, SD, SE, SF)>, [src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F) as AsExpression<Record<(SA, SB, SC, SD, SE, SF)>>>::Expression`[src]

Loading content...

Implementors

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

`type Expression = Bound<Money, PgMoney>`

`pub fn as_expression(self) -> <PgMoney as AsExpression<Money>>::Expression`[src]

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

`type Expression = Coerce<now, Timestamptz>`

`pub fn as_expression(self) -> <now as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, PgTimestamp>`

`pub fn as_expression( self ) -> <PgTimestamp as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Date, PgDate>`

`pub fn as_expression(self) -> <PgDate as AsExpression<Date>>::Expression`[src]

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

`type Expression = Bound<Interval, PgInterval>`

`pub fn as_expression(self) -> <PgInterval as AsExpression<Interval>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgMoney as AsExpression<Nullable<Money>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <now as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgTimestamp as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgDate as AsExpression<Nullable<Date>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgInterval as AsExpression<Nullable<Interval>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgNumeric as AsExpression<Nullable<Numeric>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <now as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <PgTimestamp as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Numeric, PgNumeric>`

`pub fn as_expression(self) -> <PgNumeric as AsExpression<Numeric>>::Expression`[src]

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

`type Expression = Bound<Time, PgTime>`

`pub fn as_expression(self) -> <PgTime as AsExpression<Time>>::Expression`[src]

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

`type Expression = Bound<Timestamp, PgTimestamp>`

`pub fn as_expression( self ) -> <PgTimestamp as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Money, &'expr2 &'expr PgMoney>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgMoney as AsExpression<Money>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr2 &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTimestamp as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Date, &'expr2 &'expr PgDate>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgDate as AsExpression<Date>>::Expression`[src]

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

`type Expression = Bound<Interval, &'expr2 &'expr PgInterval>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgInterval as AsExpression<Interval>>::Expression`[src]

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

`type Expression = Bound<Nullable<Money>, &'expr2 &'expr PgMoney>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgMoney as AsExpression<Nullable<Money>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr2 &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTimestamp as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Date>, &'expr2 &'expr PgDate>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgDate as AsExpression<Nullable<Date>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Interval>, &'expr2 &'expr PgInterval>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgInterval as AsExpression<Nullable<Interval>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Numeric>, &'expr2 &'expr PgNumeric>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgNumeric as AsExpression<Nullable<Numeric>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Time>, &'expr2 &'expr PgTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTimestamp as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Numeric, &'expr2 &'expr PgNumeric>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgNumeric as AsExpression<Numeric>>::Expression`[src]

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

`type Expression = Bound<Time, &'expr2 &'expr PgTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTime as AsExpression<Time>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr2 &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr2 &'expr PgTimestamp as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Money, &'expr PgMoney>`

`pub fn as_expression( self ) -> <&'expr PgMoney as AsExpression<Money>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr PgTimestamp as AsExpression<Timestamptz>>::Expression`[src]

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

`type Expression = Bound<Date, &'expr PgDate>`

`pub fn as_expression(self) -> <&'expr PgDate as AsExpression<Date>>::Expression`[src]

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

`type Expression = Bound<Interval, &'expr PgInterval>`

`pub fn as_expression( self ) -> <&'expr PgInterval as AsExpression<Interval>>::Expression`[src]

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

`type Expression = Bound<Nullable<Money>, &'expr PgMoney>`

`pub fn as_expression( self ) -> <&'expr PgMoney as AsExpression<Nullable<Money>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamptz>, &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr PgTimestamp as AsExpression<Nullable<Timestamptz>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Date>, &'expr PgDate>`

`pub fn as_expression( self ) -> <&'expr PgDate as AsExpression<Nullable<Date>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Interval>, &'expr PgInterval>`

`pub fn as_expression( self ) -> <&'expr PgInterval as AsExpression<Nullable<Interval>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Numeric>, &'expr PgNumeric>`

`pub fn as_expression( self ) -> <&'expr PgNumeric as AsExpression<Nullable<Numeric>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Time>, &'expr PgTime>`

`pub fn as_expression( self ) -> <&'expr PgTime as AsExpression<Nullable<Time>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr PgTimestamp as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Numeric, &'expr PgNumeric>`

`pub fn as_expression( self ) -> <&'expr PgNumeric as AsExpression<Numeric>>::Expression`[src]

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

`type Expression = Bound<Time, &'expr PgTime>`

`pub fn as_expression(self) -> <&'expr PgTime as AsExpression<Time>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr PgTimestamp>`

`pub fn as_expression( self ) -> <&'expr PgTimestamp as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = T`

`pub fn as_expression(self) -> T`[src]

Loading content...

Trait block_tools::db::use_diesel::expression::AsExpression[−][src]

Deriving

Associated Types

type Expression: Expression[src]

Required methods

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

Implementations on Foreign Types

pub fn as_expression( self) -> <(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) as 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)>>>::Expression[src]

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

type Expression = Bound<Nullable<Binary>, &'expr [u8]>

pub fn as_expression( self) -> <&'expr [u8] as AsExpression<Nullable<Binary>>>::Expression[src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)>

pub fn as_expression( self) -> <(A, B, C, D, E, F, G) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>>>::Expression[src]

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

type Expression = Bound<Integer, &'expr2 &'expr i32>

pub fn as_expression( self) -> <&'expr2 &'expr i32 as AsExpression<Integer>>::Expression[src]

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

type Expression = Bound<Timestamp, &'expr2 &'expr SystemTime>

pub fn as_expression( self) -> <&'expr2 &'expr SystemTime as AsExpression<Timestamp>>::Expression[src]

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

type Expression = Bound<Timestamp, &'expr2 &'expr NaiveDateTime>

pub fn as_expression( self) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Timestamp>>::Expression[src]

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

type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr NaiveDateTime>

pub fn as_expression( self) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression[src]

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

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

pub fn as_expression(self) -> <bool as AsExpression<Nullable<Bool>>>::Expression[src]

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

type Expression = Bound<Nullable<Array<ST>>, &'a &'b [T]>

pub fn as_expression( self) -> <&'a &'b [T] as AsExpression<Nullable<Array<ST>>>>::Expression[src]

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression)>

pub fn as_expression( self) -> <(A, B) as AsExpression<Record<(SA, SB)>>>::Expression[src]

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

type Expression = Bound<Time, &'expr NaiveTime>

pub fn as_expression( self) -> <&'expr NaiveTime as AsExpression<Time>>::Expression[src]

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

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

pub fn as_expression( self) -> <i64 as AsExpression<Nullable<BigInt>>>::Expression[src]

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

type Expression = Bound<Binary, &'expr2 &'expr [u8]>

pub fn as_expression( self) -> <&'expr2 &'expr [u8] as AsExpression<Binary>>::Expression[src]

impl AsExpression<Timestamp> for SystemTime[src]

type Expression = Bound<Timestamp, SystemTime>

pub fn as_expression( self) -> <SystemTime as AsExpression<Timestamp>>::Expression[src]

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

type Expression = Bound<Binary, &'expr2 &'expr Vec<u8, Global>>

pub fn as_expression( self) -> <&'expr2 &'expr Vec<u8, Global> as AsExpression<Binary>>::Expression[src]

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

type Expression = Bound<Nullable<Double>, &'expr f64>

pub fn as_expression( self) -> <&'expr f64 as AsExpression<Nullable<Double>>>::Expression[src]

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

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

pub fn as_expression( self) -> <i16 as AsExpression<Nullable<SmallInt>>>::Expression[src]

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

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

pub fn as_expression( self) -> <NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression[src]

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

type Expression = Bound<Double, &'expr f64>

pub fn as_expression(self) -> <&'expr f64 as AsExpression<Double>>::Expression[src]

impl AsExpression<Timestamp> for NaiveDateTime[src]

type Expression = Bound<Timestamp, NaiveDateTime>

pub fn as_expression( self) -> <NaiveDateTime as AsExpression<Timestamp>>::Expression[src]

impl AsExpression<Bool> for bool[src]

type Expression = Bound<Bool, bool>

pub fn as_expression(self) -> <bool as AsExpression<Bool>>::Expression[src]

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

type Expression = Bound<Double, &'expr2 &'expr f64>

pub fn as_expression( self) -> <&'expr2 &'expr f64 as AsExpression<Double>>::Expression[src]

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

type Expression = Bound<BigInt, &'expr2 &'expr i64>

pub fn as_expression( self) -> <&'expr2 &'expr i64 as AsExpression<BigInt>>::Expression[src]

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

type Expression = Bound<Text, &'expr2 &'expr str>

pub fn as_expression( self) -> <&'expr2 &'expr str as AsExpression<Text>>::Expression[src]

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

type Expression = Bound<Nullable<Array<ST>>, &'a [T]>

pub fn as_expression( self) -> <&'a [T] as AsExpression<Nullable<Array<ST>>>>::Expression[src]

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

type Expression = Bound<Array<ST>, &'a &'b [T]>

`type Expression: Expression`[src]

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

`pub fn as_expression( self ) -> <(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) as 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)>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Binary>, &'expr [u8]>`

`pub fn as_expression( self ) -> <&'expr [u8] as AsExpression<Nullable<Binary>>>::Expression`[src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B, C, D, E, F, G) as AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>>>::Expression`[src]

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

`type Expression = Bound<Integer, &'expr2 &'expr i32>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i32 as AsExpression<Integer>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr2 &'expr SystemTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr SystemTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Timestamp, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Nullable<Timestamp>, &'expr2 &'expr NaiveDateTime>`

`pub fn as_expression( self ) -> <&'expr2 &'expr NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

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

`pub fn as_expression(self) -> <bool as AsExpression<Nullable<Bool>>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a &'b [T]>`

`pub fn as_expression( self ) -> <&'a &'b [T] as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

`type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, <B as AsExpression<SB>>::Expression)>`

`pub fn as_expression( self ) -> <(A, B) as AsExpression<Record<(SA, SB)>>>::Expression`[src]

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

`type Expression = Bound<Time, &'expr NaiveTime>`

`pub fn as_expression( self ) -> <&'expr NaiveTime as AsExpression<Time>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <i64 as AsExpression<Nullable<BigInt>>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr2 &'expr [u8]>`

`pub fn as_expression( self ) -> <&'expr2 &'expr [u8] as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Timestamp, SystemTime>`

`pub fn as_expression( self ) -> <SystemTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Binary, &'expr2 &'expr Vec<u8, Global>>`

`pub fn as_expression( self ) -> <&'expr2 &'expr Vec<u8, Global> as AsExpression<Binary>>::Expression`[src]

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

`type Expression = Bound<Nullable<Double>, &'expr f64>`

`pub fn as_expression( self ) -> <&'expr f64 as AsExpression<Nullable<Double>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <i16 as AsExpression<Nullable<SmallInt>>>::Expression`[src]

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

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

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Nullable<Timestamp>>>::Expression`[src]

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

`type Expression = Bound<Double, &'expr f64>`

`pub fn as_expression(self) -> <&'expr f64 as AsExpression<Double>>::Expression`[src]

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

`type Expression = Bound<Timestamp, NaiveDateTime>`

`pub fn as_expression( self ) -> <NaiveDateTime as AsExpression<Timestamp>>::Expression`[src]

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

`type Expression = Bound<Bool, bool>`

`pub fn as_expression(self) -> <bool as AsExpression<Bool>>::Expression`[src]

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

`type Expression = Bound<Double, &'expr2 &'expr f64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr f64 as AsExpression<Double>>::Expression`[src]

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

`type Expression = Bound<BigInt, &'expr2 &'expr i64>`

`pub fn as_expression( self ) -> <&'expr2 &'expr i64 as AsExpression<BigInt>>::Expression`[src]

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

`type Expression = Bound<Text, &'expr2 &'expr str>`

`pub fn as_expression( self ) -> <&'expr2 &'expr str as AsExpression<Text>>::Expression`[src]

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

`type Expression = Bound<Nullable<Array<ST>>, &'a [T]>`

`pub fn as_expression( self ) -> <&'a [T] as AsExpression<Nullable<Array<ST>>>>::Expression`[src]

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

`type Expression = Bound<Array<ST>, &'a &'b [T]>`

`pub fn as_expression( self ) -> <&'a &'b [T] as AsExpression<Array<ST>>>::Expression`[src]

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

`type Expression = Bound<Timestamptz, DateTime<Tz>>`

`pub fn as_expression( self ) -> <DateTime<Tz> as AsExpression<Timestamptz>>::Expression`[src]

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