Trait diesel::types::FromSqlRow

pub trait FromSqlRow<A, DB: Backend + HasSqlType<A>>: Sized {
    const FIELDS_NEEDED: usize;

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

Deserialize one or more fields.

All types which implement FromSql should also implement this trait. This trait differs from FromSql in that it is also implemented by tuples.

In the future, we hope to be able to provide a blanket impl of this trait for all types which implement FromSql. However, as of Diesel 1.0, such an impl would conflict with our impl for tuples.

Associated Constants

const FIELDS_NEEDED: usize

FIELDS_NEEDED: usize = 1

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

Required Methods

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

Implementations on Foreign Types

impl<DB> FromSqlRow<Date, DB> for NaiveDate where
    DB: Backend + HasSqlType<Date>,
    NaiveDate: FromSql<Date, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Time, DB> for NaiveTime where
    DB: Backend + HasSqlType<Time>,
    NaiveTime: FromSql<Time, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamp, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamp>,
    NaiveDateTime: FromSql<Timestamp, DB>, 

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

const FIELDS_NEEDED: usize

impl<T, ST, DB> FromSqlRow<Nullable<ST>, DB> for Option<T> where
    T: FromSqlRow<ST, DB>,
    DB: Backend + HasSqlType<ST>,
    ST: NotNull, 

const FIELDS_NEEDED: usize

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

impl<DB> FromSqlRow<Bool, DB> for bool where
    DB: Backend + HasSqlType<Bool>,
    bool: FromSql<Bool, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<SmallInt, DB> for i16 where
    DB: Backend + HasSqlType<SmallInt>,
    i16: FromSql<SmallInt, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Integer, DB> for i32 where
    DB: Backend + HasSqlType<Integer>,
    i32: FromSql<Integer, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<BigInt, DB> for i64 where
    DB: Backend + HasSqlType<BigInt>,
    i64: FromSql<BigInt, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Float, DB> for f32 where
    DB: Backend + HasSqlType<Float>,
    f32: FromSql<Float, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Double, DB> for f64 where
    DB: Backend + HasSqlType<Double>,
    f64: FromSql<Double, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Text, DB> for String where
    DB: Backend + HasSqlType<Text>,
    String: FromSql<Text, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Binary, DB> for Vec<u8> where
    DB: Backend + HasSqlType<Binary>,
    Vec<u8>: FromSql<Binary, DB>, 

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

const FIELDS_NEEDED: usize

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

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

const FIELDS_NEEDED: usize

impl<A, SA, DB> FromSqlRow<(SA,), DB> for (A,) where
    DB: Backend,
    A: FromSqlRow<SA, DB>,
    DB: HasSqlType<SA>,
    DB: HasSqlType<(SA,)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

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)>, 

const FIELDS_NEEDED: usize

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

impl<DB> FromSqlRow<Numeric, DB> for BigDecimal where
    DB: Backend + HasSqlType<Numeric>,
    BigDecimal: FromSql<Numeric, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Datetime, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Datetime>,
    NaiveDateTime: FromSql<Datetime, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Tinyint, DB> for i8 where
    DB: Backend + HasSqlType<Tinyint>,
    i8: FromSql<Tinyint, DB>, 

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

const FIELDS_NEEDED: usize

impl<T, ST> FromSqlRow<Array<ST>, Pg> for Vec<T> where
    Pg: HasSqlType<ST>,
    Vec<T>: FromSql<Array<ST>, Pg>, 

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

const FIELDS_NEEDED: usize

impl<T, ST> FromSqlRow<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
    (Bound<T>, Bound<T>): FromSql<Range<ST>, Pg>,
    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamp, DB> for SystemTime where
    DB: Backend + HasSqlType<Timestamp>,
    SystemTime: FromSql<Timestamp, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamptz, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamptz>,
    NaiveDateTime: FromSql<Timestamptz, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamptz, DB> for DateTime<Utc> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<Utc>: FromSql<Timestamptz, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamp, DB> for Timespec where
    DB: Backend + HasSqlType<Timestamp>,
    Timespec: FromSql<Timestamp, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<MacAddr, DB> for [u8; 6] where
    DB: Backend + HasSqlType<MacAddr>,
    [u8; 6]: FromSql<MacAddr, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Inet, DB> for IpNetwork where
    DB: Backend + HasSqlType<Inet>,
    IpNetwork: FromSql<Inet, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Cidr, DB> for IpNetwork where
    DB: Backend + HasSqlType<Cidr>,
    IpNetwork: FromSql<Cidr, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Oid, DB> for u32 where
    DB: Backend + HasSqlType<Oid>,
    u32: FromSql<Oid, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Uuid, DB> for Uuid where
    DB: Backend + HasSqlType<Uuid>,
    Uuid: FromSql<Uuid, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Json, DB> for Value where
    DB: Backend + HasSqlType<Json>,
    Value: FromSql<Json, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Jsonb, DB> for Value where
    DB: Backend + HasSqlType<Jsonb>,
    Value: FromSql<Jsonb, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Date, DB> for String where
    DB: Backend + HasSqlType<Date>,
    String: FromSql<Date, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Time, DB> for String where
    DB: Backend + HasSqlType<Time>,
    String: FromSql<Time, DB>, 

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

const FIELDS_NEEDED: usize

impl<DB> FromSqlRow<Timestamp, DB> for String where
    DB: Backend + HasSqlType<Timestamp>,
    String: FromSql<Timestamp, DB>, 

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

const FIELDS_NEEDED: usize

Implementors

• impl<DB> FromSqlRow<Date, DB> for PgDate where
    DB: Backend + HasSqlType<Date>,
    PgDate: FromSql<Date, DB>, 
• impl<DB> FromSqlRow<Time, DB> for PgTime where
    DB: Backend + HasSqlType<Time>,
    PgTime: FromSql<Time, DB>, 
• impl<DB> FromSqlRow<Timestamp, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamp>,
    PgTimestamp: FromSql<Timestamp, DB>, 
• impl<DB> FromSqlRow<Timestamptz, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamptz>,
    PgTimestamp: FromSql<Timestamptz, DB>, 
• impl<DB> FromSqlRow<Interval, DB> for PgInterval where
    DB: Backend + HasSqlType<Interval>,
    PgInterval: FromSql<Interval, DB>, 
• impl<DB> FromSqlRow<Numeric, DB> for PgNumeric where
    DB: Backend + HasSqlType<Numeric>,
    PgNumeric: FromSql<Numeric, DB>, 
• impl<DB> FromSqlRow<Money, DB> for PgMoney where
    DB: Backend + HasSqlType<Money>,
    PgMoney: FromSql<Money, DB>,