diesel::serialize

Trait WriteTuple

Source
pub trait WriteTuple<ST> {
    // Required method
    fn write_tuple<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result;
}
Expand description

Helper trait for writing tuples as named composite types

This trait is essentially ToSql<Record<ST>> for tuples. While we can provide a valid body of to_sql, PostgreSQL doesn’t allow the use of bind parameters for unnamed composite types. For this reason, we avoid implementing ToSql directly.

This trait can be used by ToSql impls of named composite types.

§Example

    #[derive(SqlType)]
    #[postgres(type_name = "my_type")]
    struct MyType;

    #[derive(Debug)]
    struct MyStruct<'a>(i32, &'a str);

    impl<'a> ToSql<MyType, Pg> for MyStruct<'a> {
        fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
            WriteTuple::<(Integer, Text)>::write_tuple(
                &(self.0, self.1),
                out,
            )
        }
    }

Required Methods§

Source

fn write_tuple<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See trait documentation.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, BH: ToSql<SBH, Pg>, BI: ToSql<SBI, Pg>, BJ: ToSql<SBJ, Pg>, BK: ToSql<SBK, Pg>, BL: ToSql<SBL, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG> + HasSqlType<SBH> + HasSqlType<SBI> + HasSqlType<SBJ> + HasSqlType<SBK> + HasSqlType<SBL>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, BH: ToSql<SBH, Pg>, BI: ToSql<SBI, Pg>, BJ: ToSql<SBJ, Pg>, BK: ToSql<SBK, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG> + HasSqlType<SBH> + HasSqlType<SBI> + HasSqlType<SBJ> + HasSqlType<SBK>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, BH: ToSql<SBH, Pg>, BI: ToSql<SBI, Pg>, BJ: ToSql<SBJ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG> + HasSqlType<SBH> + HasSqlType<SBI> + HasSqlType<SBJ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, BH: ToSql<SBH, Pg>, BI: ToSql<SBI, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG> + HasSqlType<SBH> + HasSqlType<SBI>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, BH: ToSql<SBH, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG> + HasSqlType<SBH>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, BG: ToSql<SBG, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF> + HasSqlType<SBG>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, BF: ToSql<SBF, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE> + HasSqlType<SBF>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, BE: ToSql<SBE, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD> + HasSqlType<SBE>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, BD: ToSql<SBD, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC> + HasSqlType<SBD>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, BC: ToSql<SBC, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB> + HasSqlType<SBC>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, BB: ToSql<SBB, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA> + HasSqlType<SBB>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, BA: ToSql<SBA, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ> + HasSqlType<SBA>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, AZ: ToSql<SAZ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY> + HasSqlType<SAZ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, AY: ToSql<SAY, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX> + HasSqlType<SAY>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, AX: ToSql<SAX, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW> + HasSqlType<SAX>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, AW: ToSql<SAW, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV> + HasSqlType<SAW>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, AV: ToSql<SAV, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU> + HasSqlType<SAV>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, AU: ToSql<SAU, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT> + HasSqlType<SAU>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, AT: ToSql<SAT, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS> + HasSqlType<SAT>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, AS: ToSql<SAS, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR> + HasSqlType<SAS>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, AR: ToSql<SAR, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ> + HasSqlType<SAR>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, AQ: ToSql<SAQ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP> + HasSqlType<SAQ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, AP: ToSql<SAP, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO> + HasSqlType<SAP>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO)> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, AO: ToSql<SAO, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN> + HasSqlType<SAO>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN)> 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, AG, AH, AI, AJ, AK, AL, AM, AN)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, AN: ToSql<SAN, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM> + HasSqlType<SAN>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, AM, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM)> 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, AG, AH, AI, AJ, AK, AL, AM)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, AM: ToSql<SAM, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL> + HasSqlType<SAM>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, AL, 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, SAG, SAH, SAI, SAJ, SAK, SAL> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK, SAL)> 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, AG, AH, AI, AJ, AK, AL)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, AL: ToSql<SAL, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK> + HasSqlType<SAL>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, AK, 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, SAG, SAH, SAI, SAJ, SAK> WriteTuple<(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, SAG, SAH, SAI, SAJ, SAK)> 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, AG, AH, AI, AJ, AK)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, AK: ToSql<SAK, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ> + HasSqlType<SAK>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, AJ, 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, SAG, SAH, SAI, SAJ> WriteTuple<(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, SAG, SAH, SAI, SAJ)> 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, AG, AH, AI, AJ)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, AJ: ToSql<SAJ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI> + HasSqlType<SAJ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, AI, 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, SAG, SAH, SAI> WriteTuple<(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, SAG, SAH, SAI)> 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, AG, AH, AI)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, AI: ToSql<SAI, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH> + HasSqlType<SAI>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, AH, 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, SAG, SAH> WriteTuple<(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, SAG, SAH)> 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, AG, AH)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, AH: ToSql<SAH, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG> + HasSqlType<SAH>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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, AG, 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, SAG> WriteTuple<(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, SAG)> 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, AG)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, AA: ToSql<SAA, Pg>, AB: ToSql<SAB, Pg>, AC: ToSql<SAC, Pg>, AD: ToSql<SAD, Pg>, AE: ToSql<SAE, Pg>, AF: ToSql<SAF, Pg>, AG: ToSql<SAG, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ> + HasSqlType<SAA> + HasSqlType<SAB> + HasSqlType<SAC> + HasSqlType<SAD> + HasSqlType<SAE> + HasSqlType<SAF> + HasSqlType<SAG>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, S: ToSql<SS, Pg>, T: ToSql<ST, Pg>, U: ToSql<SU, Pg>, V: ToSql<SV, Pg>, W: ToSql<SW, Pg>, X: ToSql<SX, Pg>, Y: ToSql<SY, Pg>, Z: ToSql<SZ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR> + HasSqlType<SS> + HasSqlType<ST> + HasSqlType<SU> + HasSqlType<SV> + HasSqlType<SW> + HasSqlType<SX> + HasSqlType<SY> + HasSqlType<SZ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, R: ToSql<SR, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ> + HasSqlType<SR>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Q: ToSql<SQ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP> + HasSqlType<SQ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, P: ToSql<SP, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO> + HasSqlType<SP>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, O: ToSql<SO, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN> + HasSqlType<SO>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, N: ToSql<SN, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM> + HasSqlType<SN>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)> for (A, B, C, D, E, F, G, H, I, J, K, L, M)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, M: ToSql<SM, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL> + HasSqlType<SM>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

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> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)> for (A, B, C, D, E, F, G, H, I, J, K, L)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, L: ToSql<SL, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK> + HasSqlType<SL>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)> for (A, B, C, D, E, F, G, H, I, J, K)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, K: ToSql<SK, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ> + HasSqlType<SK>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)> for (A, B, C, D, E, F, G, H, I, J)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, J: ToSql<SJ, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI> + HasSqlType<SJ>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH, SI)> for (A, B, C, D, E, F, G, H, I)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, I: ToSql<SI, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH> + HasSqlType<SI>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> WriteTuple<(SA, SB, SC, SD, SE, SF, SG, SH)> for (A, B, C, D, E, F, G, H)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, H: ToSql<SH, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG> + HasSqlType<SH>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> WriteTuple<(SA, SB, SC, SD, SE, SF, SG)> for (A, B, C, D, E, F, G)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, G: ToSql<SG, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF> + HasSqlType<SG>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> WriteTuple<(SA, SB, SC, SD, SE, SF)> for (A, B, C, D, E, F)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, F: ToSql<SF, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE> + HasSqlType<SF>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, E, SA, SB, SC, SD, SE> WriteTuple<(SA, SB, SC, SD, SE)> for (A, B, C, D, E)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, E: ToSql<SE, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD> + HasSqlType<SE>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, D, SA, SB, SC, SD> WriteTuple<(SA, SB, SC, SD)> for (A, B, C, D)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, D: ToSql<SD, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC> + HasSqlType<SD>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, C, SA, SB, SC> WriteTuple<(SA, SB, SC)> for (A, B, C)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, C: ToSql<SC, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB> + HasSqlType<SC>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, B, SA, SB> WriteTuple<(SA, SB)> for (A, B)
where A: ToSql<SA, Pg>, B: ToSql<SB, Pg>, Pg: HasSqlType<SA> + HasSqlType<SB>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Source§

impl<A, SA> WriteTuple<(SA,)> for (A,)
where A: ToSql<SA, Pg>, Pg: HasSqlType<SA>,

Source§

fn write_tuple<_W: Write>(&self, out: &mut Output<'_, _W, Pg>) -> Result

Implementors§