pub trait WriteTuple<ST> {
    // Required method
    fn write_tuple(&self, out: &mut Output<'_, '_, Pg>) -> Result;
}
Available on crate feature postgres_backend only.
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

Implementors§