Trait diesel::types::FromSqlRow [−] [src]

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>>;
}

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>>`

Implementors

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<T, ST> FromSqlRow<Array<ST>, Pg> for Vec<T> where Pg: HasSqlType<ST>, Vec<T>: FromSql<Array<ST>, Pg>
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<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<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>