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

Required 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]

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<MacAddr, &'expr [u8; 6]>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<MacAddr>, &'expr [u8; 6]>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<MacAddr, &'expr2 &'expr [u8; 6]>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<MacAddr>, &'expr2 &'expr [u8; 6]>

fn as_expression(self) -> Self::Expression

impl AsExpression<MacAddr> for [u8; 6]

type Expression = Bound<MacAddr, [u8; 6]>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<MacAddr>, [u8; 6]>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Inet, &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Inet>, &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Inet, &'expr2 &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Inet>, &'expr2 &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

impl AsExpression<Inet> for IpNetwork

type Expression = Bound<Inet, IpNetwork>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Inet>> for IpNetwork

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Cidr, &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Cidr>, &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Cidr, &'expr2 &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Cidr>, &'expr2 &'expr IpNetwork>

fn as_expression(self) -> Self::Expression

impl AsExpression<Cidr> for IpNetwork

type Expression = Bound<Cidr, IpNetwork>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Cidr>> for IpNetwork

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

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

fn as_expression(self) -> Self::Expression

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

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression,)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, ST0, ST1> AsExpression<Record<(ST0, ST1)>> for (T0, T1) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    PgTuple<(T0::Expression, T1::Expression)>: Expression<SqlType = Record<(ST0, ST1)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, ST0, ST1, ST2> AsExpression<Record<(ST0, ST1, ST2)>> for (T0, T1, T2) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> AsExpression<Record<(ST0, ST1, ST2, ST3)>> for (T0, T1, T2, T3) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4)>> for (T0, T1, T2, T3, T4) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>> for (T0, T1, T2, T3, T4, T5) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>> for (T0, T1, T2, T3, T4, T5, T6) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    ST27: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    T27: AsExpression<ST27>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression, T27::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression, <T27 as AsExpression<ST27>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    ST27: SqlType + TypedExpressionType,
    ST28: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    T27: AsExpression<ST27>,
    T28: AsExpression<ST28>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression, T27::Expression, T28::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression, <T27 as AsExpression<ST27>>::Expression, <T28 as AsExpression<ST28>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    ST27: SqlType + TypedExpressionType,
    ST28: SqlType + TypedExpressionType,
    ST29: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    T27: AsExpression<ST27>,
    T28: AsExpression<ST28>,
    T29: AsExpression<ST29>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression, T27::Expression, T28::Expression, T29::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression, <T27 as AsExpression<ST27>>::Expression, <T28 as AsExpression<ST28>>::Expression, <T29 as AsExpression<ST29>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    ST27: SqlType + TypedExpressionType,
    ST28: SqlType + TypedExpressionType,
    ST29: SqlType + TypedExpressionType,
    ST30: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    T27: AsExpression<ST27>,
    T28: AsExpression<ST28>,
    T29: AsExpression<ST29>,
    T30: AsExpression<ST30>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression, T27::Expression, T28::Expression, T29::Expression, T30::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression, <T27 as AsExpression<ST27>>::Expression, <T28 as AsExpression<ST28>>::Expression, <T29 as AsExpression<ST29>>::Expression, <T30 as AsExpression<ST30>>::Expression)>

fn as_expression(self) -> Self::Expression

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31> AsExpression<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31)>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) where
    ST0: SqlType + TypedExpressionType,
    ST1: SqlType + TypedExpressionType,
    ST2: SqlType + TypedExpressionType,
    ST3: SqlType + TypedExpressionType,
    ST4: SqlType + TypedExpressionType,
    ST5: SqlType + TypedExpressionType,
    ST6: SqlType + TypedExpressionType,
    ST7: SqlType + TypedExpressionType,
    ST8: SqlType + TypedExpressionType,
    ST9: SqlType + TypedExpressionType,
    ST10: SqlType + TypedExpressionType,
    ST11: SqlType + TypedExpressionType,
    ST12: SqlType + TypedExpressionType,
    ST13: SqlType + TypedExpressionType,
    ST14: SqlType + TypedExpressionType,
    ST15: SqlType + TypedExpressionType,
    ST16: SqlType + TypedExpressionType,
    ST17: SqlType + TypedExpressionType,
    ST18: SqlType + TypedExpressionType,
    ST19: SqlType + TypedExpressionType,
    ST20: SqlType + TypedExpressionType,
    ST21: SqlType + TypedExpressionType,
    ST22: SqlType + TypedExpressionType,
    ST23: SqlType + TypedExpressionType,
    ST24: SqlType + TypedExpressionType,
    ST25: SqlType + TypedExpressionType,
    ST26: SqlType + TypedExpressionType,
    ST27: SqlType + TypedExpressionType,
    ST28: SqlType + TypedExpressionType,
    ST29: SqlType + TypedExpressionType,
    ST30: SqlType + TypedExpressionType,
    ST31: SqlType + TypedExpressionType,
    T0: AsExpression<ST0>,
    T1: AsExpression<ST1>,
    T2: AsExpression<ST2>,
    T3: AsExpression<ST3>,
    T4: AsExpression<ST4>,
    T5: AsExpression<ST5>,
    T6: AsExpression<ST6>,
    T7: AsExpression<ST7>,
    T8: AsExpression<ST8>,
    T9: AsExpression<ST9>,
    T10: AsExpression<ST10>,
    T11: AsExpression<ST11>,
    T12: AsExpression<ST12>,
    T13: AsExpression<ST13>,
    T14: AsExpression<ST14>,
    T15: AsExpression<ST15>,
    T16: AsExpression<ST16>,
    T17: AsExpression<ST17>,
    T18: AsExpression<ST18>,
    T19: AsExpression<ST19>,
    T20: AsExpression<ST20>,
    T21: AsExpression<ST21>,
    T22: AsExpression<ST22>,
    T23: AsExpression<ST23>,
    T24: AsExpression<ST24>,
    T25: AsExpression<ST25>,
    T26: AsExpression<ST26>,
    T27: AsExpression<ST27>,
    T28: AsExpression<ST28>,
    T29: AsExpression<ST29>,
    T30: AsExpression<ST30>,
    T31: AsExpression<ST31>,
    PgTuple<(T0::Expression, T1::Expression, T2::Expression, T3::Expression, T4::Expression, T5::Expression, T6::Expression, T7::Expression, T8::Expression, T9::Expression, T10::Expression, T11::Expression, T12::Expression, T13::Expression, T14::Expression, T15::Expression, T16::Expression, T17::Expression, T18::Expression, T19::Expression, T20::Expression, T21::Expression, T22::Expression, T23::Expression, T24::Expression, T25::Expression, T26::Expression, T27::Expression, T28::Expression, T29::Expression, T30::Expression, T31::Expression)>: Expression<SqlType = Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31)>>, 

Available on crate feature postgres_backend only.

type Expression = PgTuple<(<T0 as AsExpression<ST0>>::Expression, <T1 as AsExpression<ST1>>::Expression, <T2 as AsExpression<ST2>>::Expression, <T3 as AsExpression<ST3>>::Expression, <T4 as AsExpression<ST4>>::Expression, <T5 as AsExpression<ST5>>::Expression, <T6 as AsExpression<ST6>>::Expression, <T7 as AsExpression<ST7>>::Expression, <T8 as AsExpression<ST8>>::Expression, <T9 as AsExpression<ST9>>::Expression, <T10 as AsExpression<ST10>>::Expression, <T11 as AsExpression<ST11>>::Expression, <T12 as AsExpression<ST12>>::Expression, <T13 as AsExpression<ST13>>::Expression, <T14 as AsExpression<ST14>>::Expression, <T15 as AsExpression<ST15>>::Expression, <T16 as AsExpression<ST16>>::Expression, <T17 as AsExpression<ST17>>::Expression, <T18 as AsExpression<ST18>>::Expression, <T19 as AsExpression<ST19>>::Expression, <T20 as AsExpression<ST20>>::Expression, <T21 as AsExpression<ST21>>::Expression, <T22 as AsExpression<ST22>>::Expression, <T23 as AsExpression<ST23>>::Expression, <T24 as AsExpression<ST24>>::Expression, <T25 as AsExpression<ST25>>::Expression, <T26 as AsExpression<ST26>>::Expression, <T27 as AsExpression<ST27>>::Expression, <T28 as AsExpression<ST28>>::Expression, <T29 as AsExpression<ST29>>::Expression, <T30 as AsExpression<ST30>>::Expression, <T31 as AsExpression<ST31>>::Expression)>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Uuid, &'expr Uuid>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Uuid>, &'expr Uuid>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Uuid, &'expr2 &'expr Uuid>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Uuid> for Uuid

type Expression = Bound<Uuid, Uuid>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Uuid>> for Uuid

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamp> for SystemTime

type Expression = Bound<Timestamp, SystemTime>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamp>> for SystemTime

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Date> for NaiveDate

type Expression = Bound<Date, NaiveDate>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Date>> for NaiveDate

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Time> for NaiveTime

type Expression = Bound<Time, NaiveTime>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Time>> for NaiveTime

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamp> for NaiveDateTime

type Expression = Bound<Timestamp, NaiveDateTime>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamp>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Timestamptz> for NaiveDateTime

type Expression = Bound<Timestamptz, NaiveDateTime>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Timestamptz>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Datetime, &'expr NaiveDateTime>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Datetime> for NaiveDateTime

type Expression = Bound<Datetime, NaiveDateTime>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Datetime>> for NaiveDateTime

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Numeric, &'expr BigDecimal>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Numeric> for BigDecimal

type Expression = Bound<Numeric, BigDecimal>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Numeric>> for BigDecimal

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Json, &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Json>, &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Json, &'expr2 &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Json>, &'expr2 &'expr Value>

fn as_expression(self) -> Self::Expression

impl AsExpression<Json> for Value

type Expression = Bound<Json, Value>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Json>> for Value

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Jsonb, &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Jsonb>, &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Jsonb, &'expr2 &'expr Value>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Jsonb>, &'expr2 &'expr Value>

fn as_expression(self) -> Self::Expression

impl AsExpression<Jsonb> for Value

type Expression = Bound<Jsonb, Value>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Jsonb>> for Value

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

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>, Option<T>>

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>, &'a Option<T>>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Bool> for bool

type Expression = Bound<Bool, bool>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Bool>> for bool

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<TinyInt, &'expr i8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<TinyInt>, &'expr i8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<TinyInt, &'expr2 &'expr i8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<TinyInt>, &'expr2 &'expr i8>

fn as_expression(self) -> Self::Expression

impl AsExpression<TinyInt> for i8

type Expression = Bound<TinyInt, i8>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<TinyInt>> for i8

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<SmallInt> for i16

type Expression = Bound<SmallInt, i16>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<SmallInt>> for i16

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Integer> for i32

type Expression = Bound<Integer, i32>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Integer>> for i32

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<BigInt> for i64

type Expression = Bound<BigInt, i64>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<BigInt>> for i64

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<TinyInt>, &'expr u8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<TinyInt>>, &'expr u8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<TinyInt>, &'expr2 &'expr u8>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<TinyInt>>, &'expr2 &'expr u8>

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<TinyInt>> for u8

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<SmallInt>, &'expr u16>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<SmallInt>>, &'expr u16>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<SmallInt>, &'expr2 &'expr u16>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<SmallInt>>, &'expr2 &'expr u16>

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<SmallInt>> for u16

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<Integer>, &'expr u32>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<Integer>>, &'expr u32>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<Integer>>, &'expr2 &'expr u32>

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<Integer>> for u32

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Oid> for u32

type Expression = Bound<Oid, u32>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Oid>> for u32

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Unsigned<BigInt>, &'expr u64>

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<BigInt>>, &'expr u64>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Nullable<Unsigned<BigInt>>, &'expr2 &'expr u64>

fn as_expression(self) -> Self::Expression

impl AsExpression<Unsigned<BigInt>> for u64

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Float> for f32

type Expression = Bound<Float, f32>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Float>> for f32

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Double> for f64

type Expression = Bound<Double, f64>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Double>> for f64

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Text> for String

type Expression = Bound<Text, String>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Text>> for String

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

fn as_expression(self) -> Self::Expression

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

type Expression = Bound<Date, &'expr String>

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

impl AsExpression<Date> for String

type Expression = Bound<Date, String>

fn as_expression(self) -> Self::Expression

impl AsExpression<Nullable<Date>> for String

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression

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

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

fn as_expression(self) -> Self::Expression