Trait diesel::types::FromSqlRow

pub trait FromSqlRow<A, DB: Backend + HasSqlType<A>>: Sized {
    fn build_from_row<T: Row<DB>>(
        row: &mut T
    ) -> Result<Self, Box<Error + Send + Sync>>;

    fn fields_needed() -> usize { ... }
}

How to deserialize multiple fields, with a known type. This type is implemented for tuples of various sizes.

Required Methods

fn build_from_row<T: Row<DB>>(
    row: &mut T
) -> Result<Self, Box<Error + Send + Sync>>

Provided Methods

fn fields_needed() -> usize

The number of fields that this type will consume. Should be equal to the number of times you would call row.take() in build_from_row

Implementors

• impl<DB> FromSqlRow<Date, DB> for NaiveDate where
    DB: Backend + HasSqlType<Date>,
    NaiveDate: FromSql<Date, DB>, 
• impl<DB> FromSqlRow<Nullable<Date>, DB> for Option<NaiveDate> where
    DB: Backend + HasSqlType<Date>,
    Option<NaiveDate>: FromSql<Nullable<Date>, DB>, 
• impl<DB> FromSqlRow<Time, DB> for NaiveTime where
    DB: Backend + HasSqlType<Time>,
    NaiveTime: FromSql<Time, DB>, 
• impl<DB> FromSqlRow<Nullable<Time>, DB> for Option<NaiveTime> where
    DB: Backend + HasSqlType<Time>,
    Option<NaiveTime>: FromSql<Nullable<Time>, DB>, 
• impl<DB> FromSqlRow<Timestamp, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamp>,
    NaiveDateTime: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamp>, DB> for Option<NaiveDateTime> where
    DB: Backend + HasSqlType<Timestamp>,
    Option<NaiveDateTime>: FromSql<Nullable<Timestamp>, DB>, 
• impl<DB> FromSqlRow<Bool, DB> for bool where
    DB: Backend + HasSqlType<Bool>,
    bool: FromSql<Bool, DB>, 
• impl<DB> FromSqlRow<Nullable<Bool>, DB> for Option<bool> where
    DB: Backend + HasSqlType<Bool>,
    Option<bool>: FromSql<Nullable<Bool>, DB>, 
• impl<DB> FromSqlRow<SmallInt, DB> for i16 where
    DB: Backend + HasSqlType<SmallInt>,
    i16: FromSql<SmallInt, DB>, 
• impl<DB> FromSqlRow<Nullable<SmallInt>, DB> for Option<i16> where
    DB: Backend + HasSqlType<SmallInt>,
    Option<i16>: FromSql<Nullable<SmallInt>, DB>, 
• impl<DB> FromSqlRow<Integer, DB> for i32 where
    DB: Backend + HasSqlType<Integer>,
    i32: FromSql<Integer, DB>, 
• impl<DB> FromSqlRow<Nullable<Integer>, DB> for Option<i32> where
    DB: Backend + HasSqlType<Integer>,
    Option<i32>: FromSql<Nullable<Integer>, DB>, 
• impl<DB> FromSqlRow<BigInt, DB> for i64 where
    DB: Backend + HasSqlType<BigInt>,
    i64: FromSql<BigInt, DB>, 
• impl<DB> FromSqlRow<Nullable<BigInt>, DB> for Option<i64> where
    DB: Backend + HasSqlType<BigInt>,
    Option<i64>: FromSql<Nullable<BigInt>, DB>, 
• impl<DB> FromSqlRow<Float, DB> for f32 where
    DB: Backend + HasSqlType<Float>,
    f32: FromSql<Float, DB>, 
• impl<DB> FromSqlRow<Nullable<Float>, DB> for Option<f32> where
    DB: Backend + HasSqlType<Float>,
    Option<f32>: FromSql<Nullable<Float>, DB>, 
• impl<DB> FromSqlRow<Double, DB> for f64 where
    DB: Backend + HasSqlType<Double>,
    f64: FromSql<Double, DB>, 
• impl<DB> FromSqlRow<Nullable<Double>, DB> for Option<f64> where
    DB: Backend + HasSqlType<Double>,
    Option<f64>: FromSql<Nullable<Double>, DB>, 
• impl<DB> FromSqlRow<Text, DB> for String where
    DB: Backend + HasSqlType<Text>,
    String: FromSql<Text, DB>, 
• impl<DB> FromSqlRow<Nullable<Text>, DB> for Option<String> where
    DB: Backend + HasSqlType<Text>,
    Option<String>: FromSql<Nullable<Text>, DB>, 
• impl<DB> FromSqlRow<Binary, DB> for Vec<u8> where
    DB: Backend + HasSqlType<Binary>,
    Vec<u8>: FromSql<Binary, DB>, 
• impl<DB> FromSqlRow<Nullable<Binary>, DB> for Option<Vec<u8>> where
    DB: Backend + HasSqlType<Binary>,
    Option<Vec<u8>>: FromSql<Nullable<Binary>, DB>, 
• impl<'a, T: ?Sized, ST, DB> FromSqlRow<ST, DB> for Cow<'a, T> where
    T: 'a + ToOwned,
    DB: Backend + HasSqlType<ST>,
    Cow<'a, T>: FromSql<ST, DB>, 
• impl<A, SA, DB> FromSqlRow<(SA,), DB> for (A,) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<(SA,)>, 
• impl<A, SA, DB> FromSqlRow<Nullable<(SA,)>, DB> for Option<(A,)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<(SA,)>, 
• impl<A, B, SA, SB, DB> FromSqlRow<(SA, SB), DB> for (A, B) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<(SA, SB)>, 
• impl<A, B, SA, SB, DB> FromSqlRow<Nullable<(SA, SB)>, DB> for Option<(A, B)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<(SA, SB)>, 
• impl<A, B, C, SA, SB, SC, DB> FromSqlRow<(SA, SB, SC), DB> for (A, B, C) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<(SA, SB, SC)>, 
• impl<A, B, C, SA, SB, SC, DB> FromSqlRow<Nullable<(SA, SB, SC)>, DB> for Option<(A, B, C)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<(SA, SB, SC)>, 
• impl<A, B, C, D, SA, SB, SC, SD, DB> FromSqlRow<(SA, SB, SC, SD), DB> for (A, B, C, D) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<(SA, SB, SC, SD)>, 
• impl<A, B, C, D, SA, SB, SC, SD, DB> FromSqlRow<Nullable<(SA, SB, SC, SD)>, DB> for Option<(A, B, C, D)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<(SA, SB, SC, SD)>, 
• impl<A, B, C, D, E, SA, SB, SC, SD, SE, DB> FromSqlRow<(SA, SB, SC, SD, SE), DB> for (A, B, C, D, E) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<(SA, SB, SC, SD, SE)>, 
• impl<A, B, C, D, E, SA, SB, SC, SD, SE, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE)>, DB> for Option<(A, B, C, D, E)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<(SA, SB, SC, SD, SE)>, 
• impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF), DB> for (A, B, C, D, E, F) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF)>, 
• impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF)>, DB> for Option<(A, B, C, D, E, F)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF)>, 
• impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG), DB> for (A, B, C, D, E, F, G) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG)>, 
• impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG)>, DB> for Option<(A, B, C, D, E, F, G)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG)>, 
• impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH), DB> for (A, B, C, D, E, F, G, H) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH)>, 
• impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH)>, DB> for Option<(A, B, C, D, E, F, G, H)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH)>, 
• impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI), DB> for (A, B, C, D, E, F, G, H, I) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, 
• impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, DB> for Option<(A, B, C, D, E, F, G, H, I)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, 
• impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ), DB> for (A, B, C, D, E, F, G, H, I, J) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, 
• impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, 
• impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK), DB> for (A, B, C, D, E, F, G, H, I, J, K) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, 
• impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, 
• 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, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), DB> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, 
• 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, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K, L)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, 
• 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, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, 
• 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, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K, L, M)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, 
• 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, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, 
• 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, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, 
• 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, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    O: FromSqlRow<SO, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, 
• 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, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    O: FromSqlRow<SO, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, 
• 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, DB> FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP), DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    O: FromSqlRow<SO, DB>,
    P: FromSqlRow<SP, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, 
• 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, DB> FromSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, DB> for Option<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    B: FromSqlRow<SB, DB>,
    C: FromSqlRow<SC, DB>,
    D: FromSqlRow<SD, DB>,
    E: FromSqlRow<SE, DB>,
    F: FromSqlRow<SF, DB>,
    G: FromSqlRow<SG, DB>,
    H: FromSqlRow<SH, DB>,
    I: FromSqlRow<SI, DB>,
    J: FromSqlRow<SJ, DB>,
    K: FromSqlRow<SK, DB>,
    L: FromSqlRow<SL, DB>,
    M: FromSqlRow<SM, DB>,
    N: FromSqlRow<SN, DB>,
    O: FromSqlRow<SO, DB>,
    P: FromSqlRow<SP, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<SB>,
    DB: HasSqlType<SC>,
    DB: HasSqlType<SD>,
    DB: HasSqlType<SE>,
    DB: HasSqlType<SF>,
    DB: HasSqlType<SG>,
    DB: HasSqlType<SH>,
    DB: HasSqlType<SI>,
    DB: HasSqlType<SJ>,
    DB: HasSqlType<SK>,
    DB: HasSqlType<SL>,
    DB: HasSqlType<SM>,
    DB: HasSqlType<SN>,
    DB: HasSqlType<SO>,
    DB: HasSqlType<SP>,
    DB: HasSqlType<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, 
• impl<DB> FromSqlRow<Numeric, DB> for BigDecimal where
    DB: Backend + HasSqlType<Numeric>,
    BigDecimal: FromSql<Numeric, DB>, 
• impl<DB> FromSqlRow<Nullable<Numeric>, DB> for Option<BigDecimal> where
    DB: Backend + HasSqlType<Numeric>,
    Option<BigDecimal>: FromSql<Nullable<Numeric>, DB>, 
• impl<DB> FromSqlRow<Tinyint, DB> for i8 where
    DB: Backend + HasSqlType<Tinyint>,
    i8: FromSql<Tinyint, DB>, 
• impl<DB> FromSqlRow<Nullable<Tinyint>, DB> for Option<i8> where
    DB: Backend + HasSqlType<Tinyint>,
    Option<i8>: FromSql<Nullable<Tinyint>, DB>, 
• impl<T, ST> FromSqlRow<Array<ST>, Pg> for Vec<T> where
    Pg: HasSqlType<ST>,
    Vec<T>: FromSql<Array<ST>, Pg>, 
• impl<T, ST> FromSqlRow<Nullable<Array<ST>>, Pg> for Option<Vec<T>> where
    Pg: HasSqlType<ST>,
    Option<Vec<T>>: FromSql<Nullable<Array<ST>>, Pg>, 
• impl<DB> FromSqlRow<Timestamp, DB> for SystemTime where
    DB: Backend + HasSqlType<Timestamp>,
    SystemTime: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamp>, DB> for Option<SystemTime> where
    DB: Backend + HasSqlType<Timestamp>,
    Option<SystemTime>: FromSql<Nullable<Timestamp>, DB>, 
• impl<DB> FromSqlRow<Timestamptz, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamptz>,
    NaiveDateTime: FromSql<Timestamptz, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamptz>, DB> for Option<NaiveDateTime> where
    DB: Backend + HasSqlType<Timestamptz>,
    Option<NaiveDateTime>: FromSql<Nullable<Timestamptz>, DB>, 
• impl<DB> FromSqlRow<Timestamptz, DB> for DateTime<Utc> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<Utc>: FromSql<Timestamptz, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamptz>, DB> for Option<DateTime<Utc>> where
    DB: Backend + HasSqlType<Timestamptz>,
    Option<DateTime<Utc>>: FromSql<Nullable<Timestamptz>, DB>, 
• impl<DB> FromSqlRow<Timestamp, DB> for Timespec where
    DB: Backend + HasSqlType<Timestamp>,
    Timespec: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamp>, DB> for Option<Timespec> where
    DB: Backend + HasSqlType<Timestamp>,
    Option<Timespec>: FromSql<Nullable<Timestamp>, DB>, 
• impl<DB> FromSqlRow<Date, DB> for PgDate where
    DB: Backend + HasSqlType<Date>,
    PgDate: FromSql<Date, DB>, 
• impl<DB> FromSqlRow<Nullable<Date>, DB> for Option<PgDate> where
    DB: Backend + HasSqlType<Date>,
    Option<PgDate>: FromSql<Nullable<Date>, DB>, 
• impl<DB> FromSqlRow<Time, DB> for PgTime where
    DB: Backend + HasSqlType<Time>,
    PgTime: FromSql<Time, DB>, 
• impl<DB> FromSqlRow<Nullable<Time>, DB> for Option<PgTime> where
    DB: Backend + HasSqlType<Time>,
    Option<PgTime>: FromSql<Nullable<Time>, DB>, 
• impl<DB> FromSqlRow<Timestamp, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamp>,
    PgTimestamp: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamp>, DB> for Option<PgTimestamp> where
    DB: Backend + HasSqlType<Timestamp>,
    Option<PgTimestamp>: FromSql<Nullable<Timestamp>, DB>, 
• impl<DB> FromSqlRow<Timestamptz, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamptz>,
    PgTimestamp: FromSql<Timestamptz, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamptz>, DB> for Option<PgTimestamp> where
    DB: Backend + HasSqlType<Timestamptz>,
    Option<PgTimestamp>: FromSql<Nullable<Timestamptz>, DB>, 
• impl<DB> FromSqlRow<Interval, DB> for PgInterval where
    DB: Backend + HasSqlType<Interval>,
    PgInterval: FromSql<Interval, DB>, 
• impl<DB> FromSqlRow<Nullable<Interval>, DB> for Option<PgInterval> where
    DB: Backend + HasSqlType<Interval>,
    Option<PgInterval>: FromSql<Nullable<Interval>, DB>, 
• impl<DB> FromSqlRow<MacAddr, DB> for [u8; 6] where
    DB: Backend + HasSqlType<MacAddr>,
    [u8; 6]: FromSql<MacAddr, DB>, 
• impl<DB> FromSqlRow<Nullable<MacAddr>, DB> for Option<[u8; 6]> where
    DB: Backend + HasSqlType<MacAddr>,
    Option<[u8; 6]>: FromSql<Nullable<MacAddr>, DB>, 
• impl<DB> FromSqlRow<Inet, DB> for IpNetwork where
    DB: Backend + HasSqlType<Inet>,
    IpNetwork: FromSql<Inet, DB>, 
• impl<DB> FromSqlRow<Nullable<Inet>, DB> for Option<IpNetwork> where
    DB: Backend + HasSqlType<Inet>,
    Option<IpNetwork>: FromSql<Nullable<Inet>, DB>, 
• impl<DB> FromSqlRow<Cidr, DB> for IpNetwork where
    DB: Backend + HasSqlType<Cidr>,
    IpNetwork: FromSql<Cidr, DB>, 
• impl<DB> FromSqlRow<Nullable<Cidr>, DB> for Option<IpNetwork> where
    DB: Backend + HasSqlType<Cidr>,
    Option<IpNetwork>: FromSql<Nullable<Cidr>, DB>, 
• impl<DB> FromSqlRow<Oid, DB> for u32 where
    DB: Backend + HasSqlType<Oid>,
    u32: FromSql<Oid, DB>, 
• impl<DB> FromSqlRow<Nullable<Oid>, DB> for Option<u32> where
    DB: Backend + HasSqlType<Oid>,
    Option<u32>: FromSql<Nullable<Oid>, DB>, 
• impl<DB> FromSqlRow<Numeric, DB> for PgNumeric where
    DB: Backend + HasSqlType<Numeric>,
    PgNumeric: FromSql<Numeric, DB>, 
• impl<DB> FromSqlRow<Nullable<Numeric>, DB> for Option<PgNumeric> where
    DB: Backend + HasSqlType<Numeric>,
    Option<PgNumeric>: FromSql<Nullable<Numeric>, DB>, 
• impl<DB> FromSqlRow<Uuid, DB> for Uuid where
    DB: Backend + HasSqlType<Uuid>,
    Uuid: FromSql<Uuid, DB>, 
• impl<DB> FromSqlRow<Nullable<Uuid>, DB> for Option<Uuid> where
    DB: Backend + HasSqlType<Uuid>,
    Option<Uuid>: FromSql<Nullable<Uuid>, DB>, 
• impl<DB> FromSqlRow<Json, DB> for Value where
    DB: Backend + HasSqlType<Json>,
    Value: FromSql<Json, DB>, 
• impl<DB> FromSqlRow<Nullable<Json>, DB> for Option<Value> where
    DB: Backend + HasSqlType<Json>,
    Option<Value>: FromSql<Nullable<Json>, DB>, 
• impl<DB> FromSqlRow<Jsonb, DB> for Value where
    DB: Backend + HasSqlType<Jsonb>,
    Value: FromSql<Jsonb, DB>, 
• impl<DB> FromSqlRow<Nullable<Jsonb>, DB> for Option<Value> where
    DB: Backend + HasSqlType<Jsonb>,
    Option<Value>: FromSql<Nullable<Jsonb>, DB>, 
• impl<DB> FromSqlRow<Money, DB> for PgMoney where
    DB: Backend + HasSqlType<Money>,
    PgMoney: FromSql<Money, DB>, 
• impl<DB> FromSqlRow<Nullable<Money>, DB> for Option<PgMoney> where
    DB: Backend + HasSqlType<Money>,
    Option<PgMoney>: FromSql<Nullable<Money>, DB>, 
• impl<DB> FromSqlRow<Date, DB> for String where
    DB: Backend + HasSqlType<Date>,
    String: FromSql<Date, DB>, 
• impl<DB> FromSqlRow<Nullable<Date>, DB> for Option<String> where
    DB: Backend + HasSqlType<Date>,
    Option<String>: FromSql<Nullable<Date>, DB>, 
• impl<DB> FromSqlRow<Time, DB> for String where
    DB: Backend + HasSqlType<Time>,
    String: FromSql<Time, DB>, 
• impl<DB> FromSqlRow<Nullable<Time>, DB> for Option<String> where
    DB: Backend + HasSqlType<Time>,
    Option<String>: FromSql<Nullable<Time>, DB>, 
• impl<DB> FromSqlRow<Timestamp, DB> for String where
    DB: Backend + HasSqlType<Timestamp>,
    String: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Nullable<Timestamp>, DB> for Option<String> where
    DB: Backend + HasSqlType<Timestamp>,
    Option<String>: FromSql<Nullable<Timestamp>, DB>,