Trait diesel::expression::AsExpression

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

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

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

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

• Return self for types which are already parts of Diesel’s query builder

• Perform some implicit coercion (for example, allowing now to be used as both Timestamp and Timestamptz.

• Indicate that the type has data which will be sent separately from the query. This is generally referred as a “bind parameter”. Types which implement ToSql will generally implement AsExpression this way.

This trait could be derived

Associated Types

type Expression: Expression<SqlType = T>

The expression being returned

Required methods

fn as_expression(self) -> Self::Expression

Perform the conversion

Implementations on Foreign Types

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Array<ST>> for Vec<T>

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Nullable<Array<ST>>> for Vec<T>

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Array<ST>> for &'a Vec<T>

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Nullable<Array<ST>>> for &'a Vec<T>

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Array<ST>> for &'a &'b Vec<T>

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

fn as_expression(self) -> Self::Expression

impl<'a, 'b, ST: 'static, T> AsExpression<Nullable<Array<ST>>> for &'a &'b Vec<T>

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<MacAddr, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<MacAddr, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<MacAddr> for [u8; 6]

type Expression = Bound<MacAddr, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Inet> for &'expr IpNetwork

type Expression = Bound<Inet, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Inet>> for &'expr IpNetwork

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Inet, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Inet> for IpNetwork

type Expression = Bound<Inet, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Inet>> for IpNetwork

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Cidr> for &'expr IpNetwork

type Expression = Bound<Cidr, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Cidr>> for &'expr IpNetwork

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Cidr, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Cidr> for IpNetwork

type Expression = Bound<Cidr, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Cidr>> for IpNetwork

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

fn as_expression(self) -> Self::Expression

impl<ST: 'static, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>)

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

fn as_expression(self) -> Self::Expression

impl<'a, ST: 'static, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>)

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

fn as_expression(self) -> Self::Expression

impl<ST: 'static, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>)

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

fn as_expression(self) -> Self::Expression

impl<'a, ST: 'static, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>)

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

fn as_expression(self) -> Self::Expression

impl<A, SA> AsExpression<Record<(SA,)>> for (A,) where
    SA: SqlType + TypedExpressionType,
    A: AsExpression<SA>,
    PgTuple<(A::Expression,)>: Expression<SqlType = Record<(SA,)>>, 

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

fn as_expression(self) -> Self::Expression

impl<A, B, SA, SB> AsExpression<Record<(SA, SB)>> for (A, B) where
    SA: SqlType + TypedExpressionType,
    SB: SqlType + TypedExpressionType,
    A: AsExpression<SA>,
    B: AsExpression<SB>,
    PgTuple<(A::Expression, B::Expression)>: Expression<SqlType = Record<(SA, SB)>>, 

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

fn as_expression(self) -> Self::Expression

impl<A, B, C, SA, SB, SC> AsExpression<Record<(SA, SB, SC)>> for (A, B, C) where
    SA: SqlType + TypedExpressionType,
    SB: SqlType + TypedExpressionType,
    SC: SqlType + TypedExpressionType,
    A: AsExpression<SA>,
    B: AsExpression<SB>,
    C: AsExpression<SC>,
    PgTuple<(A::Expression, B::Expression, C::Expression)>: Expression<SqlType = Record<(SA, SB, SC)>>, 

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

fn as_expression(self) -> Self::Expression

impl<A, B, C, D, SA, SB, SC, SD> AsExpression<Record<(SA, SB, SC, SD)>> for (A, B, C, D) where
    SA: SqlType + TypedExpressionType,
    SB: SqlType + TypedExpressionType,
    SC: SqlType + TypedExpressionType,
    SD: SqlType + TypedExpressionType,
    A: AsExpression<SA>,
    B: AsExpression<SB>,
    C: AsExpression<SC>,
    D: AsExpression<SD>,
    PgTuple<(A::Expression, B::Expression, C::Expression, D::Expression)>: Expression<SqlType = Record<(SA, SB, SC, SD)>>, 

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'expr> AsExpression<Uuid> for &'expr Uuid

type Expression = Bound<Uuid, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Uuid>> for &'expr Uuid

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

fn as_expression(self) -> Self::Expression

impl<'expr2, 'expr> AsExpression<Uuid> for &'expr2 &'expr Uuid

type Expression = Bound<Uuid, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Uuid> for Uuid

type Expression = Bound<Uuid, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Uuid>> for Uuid

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Timestamp> for &'expr SystemTime

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr SystemTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamp> for SystemTime

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamp>> for SystemTime

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Date> for &'expr NaiveDate

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Date>> for &'expr NaiveDate

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Date> for NaiveDate

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Date>> for NaiveDate

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Time> for &'expr NaiveTime

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Time>> for &'expr NaiveTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Time> for NaiveTime

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Time>> for NaiveTime

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Timestamp> for &'expr NaiveDateTime

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamp> for NaiveDateTime

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamp>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Timestamptz> for &'expr NaiveDateTime

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamptz> for NaiveDateTime

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamptz>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Datetime> for &'expr NaiveDateTime

type Expression = Bound<Datetime, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Datetime>> for &'expr NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Datetime, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Datetime> for NaiveDateTime

type Expression = Bound<Datetime, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Datetime>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<Tz: TimeZone> AsExpression<Timestamptz> for DateTime<Tz>

type Expression = Bound<Timestamptz, Self>

fn as_expression(self) -> Self::Expression

impl<Tz: TimeZone> AsExpression<Nullable<Timestamptz>> for DateTime<Tz>

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Numeric> for &'expr BigDecimal

type Expression = Bound<Numeric, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr BigDecimal

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Numeric, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Numeric> for BigDecimal

type Expression = Bound<Numeric, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Numeric>> for BigDecimal

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Json> for &'expr Value

type Expression = Bound<Json, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Json>> for &'expr Value

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Json, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Json> for Value

type Expression = Bound<Json, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Json>> for Value

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Jsonb> for &'expr Value

type Expression = Bound<Jsonb, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Jsonb>> for &'expr Value

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Jsonb, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Jsonb> for Value

type Expression = Bound<Jsonb, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Jsonb>> for Value

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

fn as_expression(self) -> Self::Expression

impl<T, ST> AsExpression<Nullable<ST>> for Option<T> where
    ST: SqlType<IsNull = NotNull>,
    Nullable<ST>: TypedExpressionType, 

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

fn as_expression(self) -> Self::Expression

impl<'a, T, ST> AsExpression<Nullable<ST>> for &'a Option<T> where
    ST: SqlType<IsNull = NotNull>,
    Nullable<ST>: TypedExpressionType, 

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Bool> for &'expr bool

type Expression = Bound<Bool, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Bool>> for &'expr bool

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Bool, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Bool> for bool

type Expression = Bound<Bool, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Bool>> for bool

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<TinyInt> for &'expr i8

type Expression = Bound<TinyInt, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<TinyInt>> for &'expr i8

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<TinyInt, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<TinyInt> for i8

type Expression = Bound<TinyInt, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<TinyInt>> for i8

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<SmallInt> for &'expr i16

type Expression = Bound<SmallInt, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<SmallInt>> for &'expr i16

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<SmallInt, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<SmallInt> for i16

type Expression = Bound<SmallInt, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<SmallInt>> for i16

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Integer> for &'expr i32

type Expression = Bound<Integer, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Integer>> for &'expr i32

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Integer, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Integer> for i32

type Expression = Bound<Integer, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Integer>> for i32

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<BigInt> for &'expr i64

type Expression = Bound<BigInt, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<BigInt>> for &'expr i64

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<BigInt, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<BigInt> for i64

type Expression = Bound<BigInt, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<BigInt>> for i64

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Unsigned<TinyInt>> for &'expr u8

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<TinyInt>> for u8

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Unsigned<TinyInt>>> for u8

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Unsigned<SmallInt>> for &'expr u16

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<SmallInt>> for u16

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Unsigned<SmallInt>>> for u16

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Unsigned<Integer>> for &'expr u32

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<Integer>> for u32

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Unsigned<Integer>>> for u32

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Oid> for &'expr u32

type Expression = Bound<Oid, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Oid>> for &'expr u32

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Oid, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Oid> for u32

type Expression = Bound<Oid, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Oid>> for u32

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Unsigned<BigInt>> for &'expr u64

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<BigInt>> for u64

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Unsigned<BigInt>>> for u64

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Float> for &'expr f32

type Expression = Bound<Float, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Float>> for &'expr f32

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Float, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Float> for f32

type Expression = Bound<Float, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Float>> for f32

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Double> for &'expr f64

type Expression = Bound<Double, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Double>> for &'expr f64

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Double, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Double> for f64

type Expression = Bound<Double, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Double>> for f64

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Text> for &'expr String

type Expression = Bound<Text, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Text>> for &'expr String

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Text, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Text> for String

type Expression = Bound<Text, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Text>> for String

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Date> for &'expr String

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Date>> for &'expr String

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Date> for String

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Date>> for String

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Time> for &'expr String

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Time>> for &'expr String

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Time> for String

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Time>> for String

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Timestamp> for &'expr String

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr String

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamp> for String

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamp>> for String

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Text> for &'expr str

type Expression = Bound<Text, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Text>> for &'expr str

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Text, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Date> for &'expr str

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Date>> for &'expr str

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Date, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Time> for &'expr str

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Time>> for &'expr str

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Time, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Timestamp> for &'expr str

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr str

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Timestamp, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl<'expr> AsExpression<Binary> for &'expr Vec<u8>

type Expression = Bound<Binary, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Binary, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Binary> for Vec<u8>

type Expression = Bound<Binary, Self>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Binary>> for Vec<u8>

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Binary, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Binary, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<ST, Self>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

Implementors

impl AsExpression<Money> for PgMoney

type Expression = Bound<Money, Self>

impl AsExpression<Timestamptz> for now

type Expression = Coerce<now, Timestamptz>

impl AsExpression<Timestamptz> for PgTimestamp

type Expression = Bound<Timestamptz, Self>

impl AsExpression<Date> for PgDate

type Expression = Bound<Date, Self>

impl AsExpression<Interval> for PgInterval

type Expression = Bound<Interval, Self>

impl AsExpression<Nullable<Money>> for PgMoney

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

impl AsExpression<Nullable<Timestamptz>> for now

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

impl AsExpression<Nullable<Timestamptz>> for PgTimestamp

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

impl AsExpression<Nullable<Date>> for today

type Expression = Coerce<today, Nullable<Date>>

impl AsExpression<Nullable<Date>> for PgDate

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

impl AsExpression<Nullable<Interval>> for PgInterval

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

impl AsExpression<Nullable<Numeric>> for PgNumeric

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

impl AsExpression<Nullable<Time>> for PgTime

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

impl AsExpression<Nullable<Timestamp>> for now

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

impl AsExpression<Nullable<Timestamp>> for PgTimestamp

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

impl AsExpression<Numeric> for PgNumeric

type Expression = Bound<Numeric, Self>

impl AsExpression<Time> for PgTime

type Expression = Bound<Time, Self>

impl AsExpression<Timestamp> for PgTimestamp

type Expression = Bound<Timestamp, Self>

impl<'a> AsExpression<Nullable<Text>> for MigrationVersion<'a>

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

impl<'a> AsExpression<Text> for MigrationVersion<'a>

type Expression = Bound<Text, Self>

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

type Expression = Bound<Money, Self>

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

type Expression = Bound<Timestamptz, Self>

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

type Expression = Bound<Date, Self>

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

type Expression = Bound<Interval, Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Expression = Bound<Numeric, Self>

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

type Expression = Bound<Time, Self>

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

type Expression = Bound<Timestamp, Self>

impl<'expr2, 'expr, 'a> AsExpression<Nullable<Text>> for &'expr2 &'expr MigrationVersion<'a>

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

impl<'expr2, 'expr, 'a> AsExpression<Text> for &'expr2 &'expr MigrationVersion<'a>

type Expression = Bound<Text, Self>

impl<'expr> AsExpression<Money> for &'expr PgMoney

type Expression = Bound<Money, Self>

impl<'expr> AsExpression<Timestamptz> for &'expr PgTimestamp

type Expression = Bound<Timestamptz, Self>

impl<'expr> AsExpression<Date> for &'expr PgDate

type Expression = Bound<Date, Self>

impl<'expr> AsExpression<Interval> for &'expr PgInterval

type Expression = Bound<Interval, Self>

impl<'expr> AsExpression<Nullable<Money>> for &'expr PgMoney

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

impl<'expr> AsExpression<Nullable<Timestamptz>> for &'expr PgTimestamp

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

impl<'expr> AsExpression<Nullable<Date>> for &'expr PgDate

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

impl<'expr> AsExpression<Nullable<Interval>> for &'expr PgInterval

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

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr PgNumeric

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

impl<'expr> AsExpression<Nullable<Time>> for &'expr PgTime

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

impl<'expr> AsExpression<Nullable<Timestamp>> for &'expr PgTimestamp

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

impl<'expr> AsExpression<Numeric> for &'expr PgNumeric

type Expression = Bound<Numeric, Self>

impl<'expr> AsExpression<Time> for &'expr PgTime

type Expression = Bound<Time, Self>

impl<'expr> AsExpression<Timestamp> for &'expr PgTimestamp

type Expression = Bound<Timestamp, Self>

impl<'expr, 'a> AsExpression<Nullable<Text>> for &'expr MigrationVersion<'a>

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

impl<'expr, 'a> AsExpression<Text> for &'expr MigrationVersion<'a>

type Expression = Bound<Text, Self>

impl<T, ST> AsExpression<ST> for T where
    T: