Trait WriteTuple

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

Helper trait for writing tuples as named composite types

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

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

§Example

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

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

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

Required Methods§

Source

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

See trait documentation.

Dyn Compatibility§

This trait is not dyn compatible.

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

Implementations on Foreign Types§

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Implementors§