Struct block_tools::db::use_diesel::pg::types::sql_types::Record[−][src]

pub struct Record<ST>(_);

The Record (a.k.a. tuple) SQL type.

`ToSql` impls

Any tuple which can be serialized to each of the elements (note: There are major caveats, see the section below)

`FromSql` impls

Any tuple which can be deserialized from each of the elements.

Typically in the documentation for SQL types, we use "FromSql impls" as a shorthand for "Rust types that you can use to represent this type". For every other type, that means there is specifically an implementation of the FromSql trait.

However, PostgreSQL does not support transmission of anonymous record types as bind parameters. It only supports transmission for named composite types. For this reason, if you tried to do int_tuple_col.eq((1, 2)), we will generate the SQL int_tuple_col = ($1, $2) rather than int_tuple_col = $1 as we would for anything else.

This should not be visible during normal usage. The only time this would affect you is if you were attempting to use sql_query with tuples. Your code would not compile in that case, as the ToSql trait itself is not implemented.

You can implement ToSql for named composite types. See WriteTuple for details.

Trait Implementations

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression, <AF as AsExpression<SAF>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression, <AE as AsExpression<SAE>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression, <AD as AsExpression<SAD>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression, <AC as AsExpression<SAC>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression, <AB as AsExpression<SAB>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression, <AA as AsExpression<SAA>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression, <Z as AsExpression<SZ>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression, <Y as AsExpression<SY>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression, <X as AsExpression<SX>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression, <W as AsExpression<SW>>::Expression)>

The expression being returned

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

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

type Expression = PgTuple<(<A as AsExpression<SA>>::Expression, >::Expression, <C as AsExpression<SC>>::Expression, <D as AsExpression<SD>>::Expression, <E as AsExpression<SE>>::Expression, <F as AsExpression<SF>>::Expression, <G as AsExpression<SG>>::Expression, <H as AsExpression<SH>>::Expression, >::Expression, <J as AsExpression<SJ>>::Expression, <K as AsExpression<SK>>::Expression, <L as AsExpression<SL>>::Expression, <M as AsExpression<SM>>::Expression, <N as AsExpression<SN>>::Expression, <O as AsExpression<SO>>::Expression, >::Expression, <Q as AsExpression<SQ>>::Expression, <R as AsExpression<SR>>::Expression, <S as AsExpression<SS>>::Expression, <T as AsExpression<ST>>::Expression, >::Expression, <V as AsExpression<SV>>::Expression)>

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

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

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

The expression being returned

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

`impl<ST> Clone for Record<ST> where ST: Clone,` [src]

`pub fn clone(&self) -> Record<ST>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<ST> Copy for Record<ST> where ST: Copy,` [src]

`impl<ST> Debug for Record<ST> where ST: Debug,` [src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<ST> Default for Record<ST> where ST: Default,` [src]

`pub fn default() -> Record<ST>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

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

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, O: FromSql<SO, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, P: FromSql<SP, Pg>, A: FromSql<SA, Pg>, R: FromSql<SR, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, N: FromSql<SN, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, Q: FromSql<SQ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, O: FromSql<SO, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, P: FromSql<SP, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, N: FromSql<SN, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, Q: FromSql<SQ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, O: FromSql<SO, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, P: FromSql<SP, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, N: FromSql<SN, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, O: FromSql<SO, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, N: FromSql<SN, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, N: FromSql<SN, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, M: FromSql<SM, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, L: FromSql<SL, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>, [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, K: FromSql<SK, Pg>, I: FromSql<SI, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg> for (A, B, C, D, E, F, G, H, I, J) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, I: FromSql<SI, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>, J: FromSql<SJ, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, I: FromSql<SI, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, H: FromSql<SH, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, G: FromSql<SG, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where C: FromSql<SC, Pg>, F: FromSql<SF, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSql<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, D, SA, SB, SC, SD> FromSql<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, C, SA, SB, SC> FromSql<Record<(SA, SB, SC)>, Pg> for (A, B, C) where C: FromSql<SC, Pg>, A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`impl<A, B, SA, SB> FromSql<Record<(SA, SB)>, Pg> for (A, B) where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,` [src]

Struct block_tools::db::use_diesel::pg::types::sql_types::Record[−][src]

ToSql impls

FromSql impls

Caveats about serialization

Trait Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<ST> Clone for Record<ST> where ST: Clone, [src]

pub fn clone(&self) -> Record<ST>[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<ST> Copy for Record<ST> where ST: Copy, [src]

impl<ST> Debug for Record<ST> where ST: Debug, [src]

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>[src]

impl<ST> Default for Record<ST> where ST: Default, [src]

pub fn default() -> Record<ST>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>>[src]

pub fn from_sql( bytes: Option<&[u8]>) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>>[src]

`ToSql` impls

`FromSql` impls

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<ST> Clone for Record<ST> where ST: Clone,` [src]

`pub fn clone(&self) -> Record<ST>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<ST> Copy for Record<ST> where ST: Copy,` [src]

`impl<ST> Debug for Record<ST> where ST: Debug,` [src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<ST> Default for Record<ST> where ST: Default,` [src]

`pub fn default() -> Record<ST>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>>`[src]

`pub fn from_sql( bytes: Option<&[u8]> ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>>`[src]