diesel::serialize

Trait WriteTuple

source
pub trait WriteTuple<ST> {
    // Required method
    fn write_tuple(&self, out: &mut Output<'_, '_, 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)]
    #[diesel(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<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
            WriteTuple::<(Integer, Text)>::write_tuple(
                &(self.0, self.1),
                &mut out.reborrow(),
            )
        }
    }

Required Methods§

source

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

See trait documentation.

Implementations on Foreign Types§

source§

impl<T0, ST0> WriteTuple<(ST0,)> for (T0,)
where T0: ToSql<ST0, Pg>, Pg: HasSqlType<ST0>,

source§

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

source§

impl<T0, T1, ST0, ST1> WriteTuple<(ST0, ST1)> for (T0, T1)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1>,

source§

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

source§

impl<T0, T1, T2, ST0, ST1, ST2> WriteTuple<(ST0, ST1, ST2)> for (T0, T1, T2)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2>,

source§

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

source§

impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> WriteTuple<(ST0, ST1, ST2, ST3)> for (T0, T1, T2, T3)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3>,

source§

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

source§

impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> WriteTuple<(ST0, ST1, ST2, ST3, ST4)> for (T0, T1, T2, T3, T4)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5)> for (T0, T1, T2, T3, T4, T5)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)> for (T0, T1, T2, T3, T4, T5, T6)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)> for (T0, T1, T2, T3, T4, T5, T6, T7)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15>,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, T59: ToSql<ST59, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58> + HasSqlType<ST59>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, T59: ToSql<ST59, Pg>, T60: ToSql<ST60, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58> + HasSqlType<ST59> + HasSqlType<ST60>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, T59: ToSql<ST59, Pg>, T60: ToSql<ST60, Pg>, T61: ToSql<ST61, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58> + HasSqlType<ST59> + HasSqlType<ST60> + HasSqlType<ST61>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61, ST62> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61, ST62)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, T59: ToSql<ST59, Pg>, T60: ToSql<ST60, Pg>, T61: ToSql<ST61, Pg>, T62: ToSql<ST62, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58> + HasSqlType<ST59> + HasSqlType<ST60> + HasSqlType<ST61> + HasSqlType<ST62>,

source§

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

source§

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61, ST62, ST63> WriteTuple<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, ST32, ST33, ST34, ST35, ST36, ST37, ST38, ST39, ST40, ST41, ST42, ST43, ST44, ST45, ST46, ST47, ST48, ST49, ST50, ST51, ST52, ST53, ST54, ST55, ST56, ST57, ST58, ST59, ST60, ST61, ST62, ST63)> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63)
where T0: ToSql<ST0, Pg>, T1: ToSql<ST1, Pg>, T2: ToSql<ST2, Pg>, T3: ToSql<ST3, Pg>, T4: ToSql<ST4, Pg>, T5: ToSql<ST5, Pg>, T6: ToSql<ST6, Pg>, T7: ToSql<ST7, Pg>, T8: ToSql<ST8, Pg>, T9: ToSql<ST9, Pg>, T10: ToSql<ST10, Pg>, T11: ToSql<ST11, Pg>, T12: ToSql<ST12, Pg>, T13: ToSql<ST13, Pg>, T14: ToSql<ST14, Pg>, T15: ToSql<ST15, Pg>, T16: ToSql<ST16, Pg>, T17: ToSql<ST17, Pg>, T18: ToSql<ST18, Pg>, T19: ToSql<ST19, Pg>, T20: ToSql<ST20, Pg>, T21: ToSql<ST21, Pg>, T22: ToSql<ST22, Pg>, T23: ToSql<ST23, Pg>, T24: ToSql<ST24, Pg>, T25: ToSql<ST25, Pg>, T26: ToSql<ST26, Pg>, T27: ToSql<ST27, Pg>, T28: ToSql<ST28, Pg>, T29: ToSql<ST29, Pg>, T30: ToSql<ST30, Pg>, T31: ToSql<ST31, Pg>, T32: ToSql<ST32, Pg>, T33: ToSql<ST33, Pg>, T34: ToSql<ST34, Pg>, T35: ToSql<ST35, Pg>, T36: ToSql<ST36, Pg>, T37: ToSql<ST37, Pg>, T38: ToSql<ST38, Pg>, T39: ToSql<ST39, Pg>, T40: ToSql<ST40, Pg>, T41: ToSql<ST41, Pg>, T42: ToSql<ST42, Pg>, T43: ToSql<ST43, Pg>, T44: ToSql<ST44, Pg>, T45: ToSql<ST45, Pg>, T46: ToSql<ST46, Pg>, T47: ToSql<ST47, Pg>, T48: ToSql<ST48, Pg>, T49: ToSql<ST49, Pg>, T50: ToSql<ST50, Pg>, T51: ToSql<ST51, Pg>, T52: ToSql<ST52, Pg>, T53: ToSql<ST53, Pg>, T54: ToSql<ST54, Pg>, T55: ToSql<ST55, Pg>, T56: ToSql<ST56, Pg>, T57: ToSql<ST57, Pg>, T58: ToSql<ST58, Pg>, T59: ToSql<ST59, Pg>, T60: ToSql<ST60, Pg>, T61: ToSql<ST61, Pg>, T62: ToSql<ST62, Pg>, T63: ToSql<ST63, Pg>, Pg: HasSqlType<ST0> + HasSqlType<ST1> + HasSqlType<ST2> + HasSqlType<ST3> + HasSqlType<ST4> + HasSqlType<ST5> + HasSqlType<ST6> + HasSqlType<ST7> + HasSqlType<ST8> + HasSqlType<ST9> + HasSqlType<ST10> + HasSqlType<ST11> + HasSqlType<ST12> + HasSqlType<ST13> + HasSqlType<ST14> + HasSqlType<ST15> + HasSqlType<ST16> + HasSqlType<ST17> + HasSqlType<ST18> + HasSqlType<ST19> + HasSqlType<ST20> + HasSqlType<ST21> + HasSqlType<ST22> + HasSqlType<ST23> + HasSqlType<ST24> + HasSqlType<ST25> + HasSqlType<ST26> + HasSqlType<ST27> + HasSqlType<ST28> + HasSqlType<ST29> + HasSqlType<ST30> + HasSqlType<ST31> + HasSqlType<ST32> + HasSqlType<ST33> + HasSqlType<ST34> + HasSqlType<ST35> + HasSqlType<ST36> + HasSqlType<ST37> + HasSqlType<ST38> + HasSqlType<ST39> + HasSqlType<ST40> + HasSqlType<ST41> + HasSqlType<ST42> + HasSqlType<ST43> + HasSqlType<ST44> + HasSqlType<ST45> + HasSqlType<ST46> + HasSqlType<ST47> + HasSqlType<ST48> + HasSqlType<ST49> + HasSqlType<ST50> + HasSqlType<ST51> + HasSqlType<ST52> + HasSqlType<ST53> + HasSqlType<ST54> + HasSqlType<ST55> + HasSqlType<ST56> + HasSqlType<ST57> + HasSqlType<ST58> + HasSqlType<ST59> + HasSqlType<ST60> + HasSqlType<ST61> + HasSqlType<ST62> + HasSqlType<ST63>,

source§

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

Implementors§