[−][src]Trait diesel::expression::AsExpression
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 bothTimestamp
andTimestamptz
. -
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 implementAsExpression
this way.
Deriving
This trait can be automatically derived for any type which implements ToSql
.
The type must be annotated with #[sql_type = "SomeType"]
.
If that annotation appears multiple times,
implementations will be generated for each one of them.
This will generate the following impls:
impl AsExpression<SqlType> for YourType
impl AsExpression<Nullable<SqlType>> for YourType
impl AsExpression<SqlType> for &'a YourType
impl AsExpression<Nullable<SqlType>> for &'a YourType
impl AsExpression<SqlType> for &'a &'b YourType
impl AsExpression<Nullable<SqlType>> for &'a &'b YourType
If your type is unsized,
you can specify this by adding the annotation #[diesel(not_sized)]
.
This will skip the impls for non-reference types.
Associated Types
type Expression: Expression<SqlType = T>
The expression being returned
Required methods
fn as_expression(self) -> Self::Expression
Perform the conversion
Implementations on Foreign Types
impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a [T]
[src]
type Expression = Bound<Array<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a [T]
[src]
type Expression = Bound<Nullable<Array<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b [T]
[src]
type Expression = Bound<Array<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b [T]
[src]
type Expression = Bound<Nullable<Array<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Array<ST>> for Vec<T>
[src]
type Expression = Bound<Array<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for Vec<T>
[src]
type Expression = Bound<Nullable<Array<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a Vec<T>
[src]
type Expression = Bound<Array<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a Vec<T>
[src]
type Expression = Bound<Nullable<Array<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Array<ST>> for &'a &'b Vec<T>
[src]
type Expression = Bound<Array<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, ST, T> AsExpression<Nullable<Array<ST>>> for &'a &'b Vec<T>
[src]
type Expression = Bound<Nullable<Array<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamp> for &'expr Timespec
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr Timespec
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr Timespec
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr Timespec
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Timestamp> for Timespec
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Timestamp>> for Timespec
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Json> for &'expr Value
[src]
type Expression = Bound<Json, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Json>> for &'expr Value
[src]
type Expression = Bound<Nullable<Json>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Json> for &'expr2 &'expr Value
[src]
type Expression = Bound<Json, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Json>> for &'expr2 &'expr Value
[src]
type Expression = Bound<Nullable<Json>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Json> for Value
[src]
type Expression = Bound<Json, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Json>> for Value
[src]
type Expression = Bound<Nullable<Json>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Jsonb> for &'expr Value
[src]
type Expression = Bound<Jsonb, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Jsonb>> for &'expr Value
[src]
type Expression = Bound<Nullable<Jsonb>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Jsonb> for &'expr2 &'expr Value
[src]
type Expression = Bound<Jsonb, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Jsonb>> for &'expr2 &'expr Value
[src]
type Expression = Bound<Nullable<Jsonb>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Jsonb> for Value
[src]
type Expression = Bound<Jsonb, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Jsonb>> for Value
[src]
type Expression = Bound<Nullable<Jsonb>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<MacAddr> for &'expr [u8; 6]
[src]
type Expression = Bound<MacAddr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<MacAddr>> for &'expr [u8; 6]
[src]
type Expression = Bound<Nullable<MacAddr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<MacAddr> for &'expr2 &'expr [u8; 6]
[src]
type Expression = Bound<MacAddr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<MacAddr>> for &'expr2 &'expr [u8; 6]
[src]
type Expression = Bound<Nullable<MacAddr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<MacAddr> for [u8; 6]
[src]
type Expression = Bound<MacAddr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<MacAddr>> for [u8; 6]
[src]
type Expression = Bound<Nullable<MacAddr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Inet> for &'expr IpNetwork
[src]
type Expression = Bound<Inet, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Inet>> for &'expr IpNetwork
[src]
type Expression = Bound<Nullable<Inet>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Inet> for &'expr2 &'expr IpNetwork
[src]
type Expression = Bound<Inet, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Inet>> for &'expr2 &'expr IpNetwork
[src]
type Expression = Bound<Nullable<Inet>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Inet> for IpNetwork
[src]
type Expression = Bound<Inet, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Inet>> for IpNetwork
[src]
type Expression = Bound<Nullable<Inet>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Cidr> for &'expr IpNetwork
[src]
type Expression = Bound<Cidr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Cidr>> for &'expr IpNetwork
[src]
type Expression = Bound<Nullable<Cidr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Cidr> for &'expr2 &'expr IpNetwork
[src]
type Expression = Bound<Cidr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Cidr>> for &'expr2 &'expr IpNetwork
[src]
type Expression = Bound<Nullable<Cidr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Cidr> for IpNetwork
[src]
type Expression = Bound<Cidr, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Cidr>> for IpNetwork
[src]
type Expression = Bound<Nullable<Cidr>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<ST, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>)
[src]
type Expression = SqlBound<Range<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, ST, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>)
[src]
type Expression = SqlBound<Range<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<ST, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>)
[src]
type Expression = SqlBound<Nullable<Range<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, ST, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>)
[src]
type Expression = SqlBound<Nullable<Range<ST>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<A, SA> AsExpression<Record<(SA,)>> for (A,) where
A: AsExpression<SA>,
PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,
[src]
A: AsExpression<SA>,
PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>,
type Expression = PgTuple<(A::Expression,)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, SA, SB> AsExpression<Record<(SA, SB)>> for (A, B) where
A: AsExpression<SA>,
B: AsExpression<SB>,
PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>,
type Expression = PgTuple<(A::Expression, B::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, SA, SB, SC> AsExpression<Record<(SA, SB, SC)>> for (A, B, C) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, SA, SB, SC, SD> AsExpression<Record<(SA, SB, SC, SD)>> for (A, B, C, D) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, SA, SB, SC, SD, SE> AsExpression<Record<(SA, SB, SC, SD, SE)>> for (A, B, C, D, E) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> AsExpression<Record<(SA, SB, SC, SD, SE, SF)>> for (A, B, C, D, E, F) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG)>> for (A, B, C, D, E, F, G) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>> for (A, B, C, D, E, F, G, H) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>> for (A, B, C, D, E, F, G, H, I) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>> for (A, B, C, D, E, F, G, H, I, J) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>> for (A, B, C, D, E, F, G, H, I, J, K) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>> for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
AE: AsExpression<SAE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
AE: AsExpression<SAE>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF> AsExpression<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) where
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
AE: AsExpression<SAE>,
AF: AsExpression<SAF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>,
[src]
A: AsExpression<SA>,
B: AsExpression<SB>,
C: AsExpression<SC>,
D: AsExpression<SD>,
E: AsExpression<SE>,
F: AsExpression<SF>,
G: AsExpression<SG>,
H: AsExpression<SH>,
I: AsExpression<SI>,
J: AsExpression<SJ>,
K: AsExpression<SK>,
L: AsExpression<SL>,
M: AsExpression<SM>,
N: AsExpression<SN>,
O: AsExpression<SO>,
P: AsExpression<SP>,
Q: AsExpression<SQ>,
R: AsExpression<SR>,
S: AsExpression<SS>,
T: AsExpression<ST>,
U: AsExpression<SU>,
V: AsExpression<SV>,
W: AsExpression<SW>,
X: AsExpression<SX>,
Y: AsExpression<SY>,
Z: AsExpression<SZ>,
AA: AsExpression<SAA>,
AB: AsExpression<SAB>,
AC: AsExpression<SAC>,
AD: AsExpression<SAD>,
AE: AsExpression<SAE>,
AF: AsExpression<SAF>,
PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>>,
type Expression = PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression, E::Expression, F::Expression, G::Expression, H::Expression, I::Expression, J::Expression, K::Expression, L::Expression, M::Expression, N::Expression, O::Expression, P::Expression, Q::Expression, R::Expression, S::Expression, T::Expression, U::Expression, V::Expression, W::Expression, X::Expression, Y::Expression, Z::Expression, AA::Expression, AB::Expression, AC::Expression, AD::Expression, AE::Expression, AF::Expression)>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Uuid> for &'expr Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Uuid>> for &'expr2 &'expr Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Uuid> for Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Uuid>> for Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Uuid> for &'expr Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Uuid>> for &'expr2 &'expr Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Uuid> for Uuid
[src]
type Expression = Bound<Uuid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Uuid>> for Uuid
[src]
type Expression = Bound<Nullable<Uuid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamp> for &'expr SystemTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr SystemTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr SystemTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr SystemTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Timestamp> for SystemTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Timestamp>> for SystemTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Date> for &'expr NaiveDate
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Date>> for &'expr NaiveDate
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr NaiveDate
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr NaiveDate
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Date> for NaiveDate
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Date>> for NaiveDate
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Time> for &'expr NaiveTime
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Time>> for &'expr NaiveTime
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr NaiveTime
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr NaiveTime
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Time> for NaiveTime
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Time>> for NaiveTime
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamp> for &'expr NaiveDateTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Timestamp> for NaiveDateTime
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Timestamp>> for NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamptz> for &'expr NaiveDateTime
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamptz> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Timestamptz> for NaiveDateTime
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Timestamptz>> for NaiveDateTime
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Datetime> for &'expr NaiveDateTime
[src]
type Expression = Bound<Datetime, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Datetime>> for &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Datetime>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Datetime> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Datetime, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Datetime>> for &'expr2 &'expr NaiveDateTime
[src]
type Expression = Bound<Nullable<Datetime>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Datetime> for NaiveDateTime
[src]
type Expression = Bound<Datetime, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Datetime>> for NaiveDateTime
[src]
type Expression = Bound<Nullable<Datetime>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr DateTime<Tz>
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr DateTime<Tz>
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Timestamptz> for &'expr2 &'expr DateTime<Tz>
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr, Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for &'expr2 &'expr DateTime<Tz>
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<Tz: TimeZone> AsExpression<Timestamptz> for DateTime<Tz>
[src]
type Expression = Bound<Timestamptz, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for DateTime<Tz>
[src]
type Expression = Bound<Nullable<Timestamptz>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Numeric> for &'expr BigDecimal
[src]
type Expression = Bound<Numeric, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Numeric>> for &'expr BigDecimal
[src]
type Expression = Bound<Nullable<Numeric>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Numeric> for &'expr2 &'expr BigDecimal
[src]
type Expression = Bound<Numeric, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Numeric>> for &'expr2 &'expr BigDecimal
[src]
type Expression = Bound<Nullable<Numeric>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Numeric> for BigDecimal
[src]
type Expression = Bound<Numeric, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Numeric>> for BigDecimal
[src]
type Expression = Bound<Nullable<Numeric>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<T, ST> AsExpression<Nullable<ST>> for Option<T> where
ST: NotNull,
[src]
ST: NotNull,
type Expression = Bound<Nullable<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, T, ST> AsExpression<Nullable<ST>> for &'a Option<T> where
ST: NotNull,
[src]
ST: NotNull,
type Expression = Bound<Nullable<ST>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Bool> for &'expr bool
[src]
type Expression = Bound<Bool, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Bool>> for &'expr bool
[src]
type Expression = Bound<Nullable<Bool>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Bool> for &'expr2 &'expr bool
[src]
type Expression = Bound<Bool, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Bool>> for &'expr2 &'expr bool
[src]
type Expression = Bound<Nullable<Bool>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Bool> for bool
[src]
type Expression = Bound<Bool, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Bool>> for bool
[src]
type Expression = Bound<Nullable<Bool>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<TinyInt> for &'expr i8
[src]
type Expression = Bound<TinyInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<TinyInt>> for &'expr i8
[src]
type Expression = Bound<Nullable<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<TinyInt> for &'expr2 &'expr i8
[src]
type Expression = Bound<TinyInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<TinyInt>> for &'expr2 &'expr i8
[src]
type Expression = Bound<Nullable<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<TinyInt> for i8
[src]
type Expression = Bound<TinyInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<TinyInt>> for i8
[src]
type Expression = Bound<Nullable<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<SmallInt> for &'expr i16
[src]
type Expression = Bound<SmallInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<SmallInt>> for &'expr i16
[src]
type Expression = Bound<Nullable<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<SmallInt> for &'expr2 &'expr i16
[src]
type Expression = Bound<SmallInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<SmallInt>> for &'expr2 &'expr i16
[src]
type Expression = Bound<Nullable<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<SmallInt> for i16
[src]
type Expression = Bound<SmallInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<SmallInt>> for i16
[src]
type Expression = Bound<Nullable<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Integer> for &'expr i32
[src]
type Expression = Bound<Integer, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Integer>> for &'expr i32
[src]
type Expression = Bound<Nullable<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Integer> for &'expr2 &'expr i32
[src]
type Expression = Bound<Integer, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Integer>> for &'expr2 &'expr i32
[src]
type Expression = Bound<Nullable<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Integer> for i32
[src]
type Expression = Bound<Integer, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Integer>> for i32
[src]
type Expression = Bound<Nullable<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<BigInt> for &'expr i64
[src]
type Expression = Bound<BigInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<BigInt>> for &'expr i64
[src]
type Expression = Bound<Nullable<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<BigInt> for &'expr2 &'expr i64
[src]
type Expression = Bound<BigInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<BigInt>> for &'expr2 &'expr i64
[src]
type Expression = Bound<Nullable<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<BigInt> for i64
[src]
type Expression = Bound<BigInt, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<BigInt>> for i64
[src]
type Expression = Bound<Nullable<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Unsigned<TinyInt>> for &'expr u8
[src]
type Expression = Bound<Unsigned<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Unsigned<TinyInt>>> for &'expr u8
[src]
type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Unsigned<TinyInt>> for &'expr2 &'expr u8
[src]
type Expression = Bound<Unsigned<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<TinyInt>>> for &'expr2 &'expr u8
[src]
type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Unsigned<TinyInt>> for u8
[src]
type Expression = Bound<Unsigned<TinyInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Unsigned<TinyInt>>> for u8
[src]
type Expression = Bound<Nullable<Unsigned<TinyInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Unsigned<SmallInt>> for &'expr u16
[src]
type Expression = Bound<Unsigned<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Unsigned<SmallInt>>> for &'expr u16
[src]
type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Unsigned<SmallInt>> for &'expr2 &'expr u16
[src]
type Expression = Bound<Unsigned<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<SmallInt>>> for &'expr2 &'expr u16
[src]
type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Unsigned<SmallInt>> for u16
[src]
type Expression = Bound<Unsigned<SmallInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Unsigned<SmallInt>>> for u16
[src]
type Expression = Bound<Nullable<Unsigned<SmallInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Unsigned<Integer>> for &'expr u32
[src]
type Expression = Bound<Unsigned<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Unsigned<Integer>>> for &'expr u32
[src]
type Expression = Bound<Nullable<Unsigned<Integer>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Unsigned<Integer>> for &'expr2 &'expr u32
[src]
type Expression = Bound<Unsigned<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<Integer>>> for &'expr2 &'expr u32
[src]
type Expression = Bound<Nullable<Unsigned<Integer>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Unsigned<Integer>> for u32
[src]
type Expression = Bound<Unsigned<Integer>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Unsigned<Integer>>> for u32
[src]
type Expression = Bound<Nullable<Unsigned<Integer>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Oid> for &'expr u32
[src]
type Expression = Bound<Oid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Oid>> for &'expr u32
[src]
type Expression = Bound<Nullable<Oid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Oid> for &'expr2 &'expr u32
[src]
type Expression = Bound<Oid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Oid>> for &'expr2 &'expr u32
[src]
type Expression = Bound<Nullable<Oid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Oid> for u32
[src]
type Expression = Bound<Oid, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Oid>> for u32
[src]
type Expression = Bound<Nullable<Oid>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Unsigned<BigInt>> for &'expr u64
[src]
type Expression = Bound<Unsigned<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Unsigned<BigInt>>> for &'expr u64
[src]
type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Unsigned<BigInt>> for &'expr2 &'expr u64
[src]
type Expression = Bound<Unsigned<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Unsigned<BigInt>>> for &'expr2 &'expr u64
[src]
type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Unsigned<BigInt>> for u64
[src]
type Expression = Bound<Unsigned<BigInt>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Unsigned<BigInt>>> for u64
[src]
type Expression = Bound<Nullable<Unsigned<BigInt>>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Float> for &'expr f32
[src]
type Expression = Bound<Float, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Float>> for &'expr f32
[src]
type Expression = Bound<Nullable<Float>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Float> for &'expr2 &'expr f32
[src]
type Expression = Bound<Float, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Float>> for &'expr2 &'expr f32
[src]
type Expression = Bound<Nullable<Float>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Float> for f32
[src]
type Expression = Bound<Float, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Float>> for f32
[src]
type Expression = Bound<Nullable<Float>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Double> for &'expr f64
[src]
type Expression = Bound<Double, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Double>> for &'expr f64
[src]
type Expression = Bound<Nullable<Double>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Double> for &'expr2 &'expr f64
[src]
type Expression = Bound<Double, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Double>> for &'expr2 &'expr f64
[src]
type Expression = Bound<Nullable<Double>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Double> for f64
[src]
type Expression = Bound<Double, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Double>> for f64
[src]
type Expression = Bound<Nullable<Double>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Text> for &'expr String
[src]
type Expression = Bound<Text, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Text>> for &'expr String
[src]
type Expression = Bound<Nullable<Text>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Text> for &'expr2 &'expr String
[src]
type Expression = Bound<Text, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Text>> for &'expr2 &'expr String
[src]
type Expression = Bound<Nullable<Text>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Text> for String
[src]
type Expression = Bound<Text, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Text>> for String
[src]
type Expression = Bound<Nullable<Text>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Date> for &'expr String
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Date>> for &'expr String
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr String
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr String
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Date> for String
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Date>> for String
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Time> for &'expr String
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Time>> for &'expr String
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr String
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr String
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Time> for String
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Time>> for String
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamp> for &'expr String
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr String
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr String
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr String
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Timestamp> for String
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Timestamp>> for String
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Text> for &'expr str
[src]
type Expression = Bound<Text, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Text>> for &'expr str
[src]
type Expression = Bound<Nullable<Text>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Text> for &'expr2 &'expr str
[src]
type Expression = Bound<Text, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Text>> for &'expr2 &'expr str
[src]
type Expression = Bound<Nullable<Text>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Date> for &'expr str
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Date>> for &'expr str
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Date> for &'expr2 &'expr str
[src]
type Expression = Bound<Date, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Date>> for &'expr2 &'expr str
[src]
type Expression = Bound<Nullable<Date>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Time> for &'expr str
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Time>> for &'expr str
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Time> for &'expr2 &'expr str
[src]
type Expression = Bound<Time, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Time>> for &'expr2 &'expr str
[src]
type Expression = Bound<Nullable<Time>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Timestamp> for &'expr str
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr str
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Timestamp> for &'expr2 &'expr str
[src]
type Expression = Bound<Timestamp, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Timestamp>> for &'expr2 &'expr str
[src]
type Expression = Bound<Nullable<Timestamp>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Binary> for &'expr Vec<u8>
[src]
type Expression = Bound<Binary, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Binary>> for &'expr Vec<u8>
[src]
type Expression = Bound<Nullable<Binary>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Binary> for &'expr2 &'expr Vec<u8>
[src]
type Expression = Bound<Binary, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Binary>> for &'expr2 &'expr Vec<u8>
[src]
type Expression = Bound<Nullable<Binary>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Binary> for Vec<u8>
[src]
type Expression = Bound<Binary, Self>
fn as_expression(self) -> Self::Expression
[src]
impl AsExpression<Nullable<Binary>> for Vec<u8>
[src]
type Expression = Bound<Nullable<Binary>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Binary> for &'expr [u8]
[src]
type Expression = Bound<Binary, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr> AsExpression<Nullable<Binary>> for &'expr [u8]
[src]
type Expression = Bound<Nullable<Binary>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Binary> for &'expr2 &'expr [u8]
[src]
type Expression = Bound<Binary, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'expr2, 'expr> AsExpression<Nullable<Binary>> for &'expr2 &'expr [u8]
[src]
type Expression = Bound<Nullable<Binary>, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, T: ?Sized, ST> AsExpression<ST> for Cow<'a, T> where
T: 'a + ToOwned,
Bound<ST, Cow<'a, T>>: Expression<SqlType = ST>,
[src]
T: 'a + ToOwned,
Bound<ST, Cow<'a, T>>: Expression<SqlType = ST>,
type Expression = Bound<ST, Self>
fn as_expression(self) -> Self::Expression
[src]
impl<'a, 'b, T: ?Sized, ST> AsExpression<ST> for &'b Cow<'a, T> where
T: 'a + ToOwned,
Bound<ST, &'b T>: Expression<SqlType = ST>,
[src]
T: 'a + ToOwned,
Bound<ST, &'b T>: Expression<SqlType = ST>,