Trait diesel::deserialize::FromSqlRow

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

    fn build_from_row<T: Row<DB>>(row: &mut T) -> Result<Self>;
}

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. Implementations of this trait are usually derived.

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.

Deriving

This trait can be automatically derived by Diesel for any type which implements FromSql. There are no options or special considerations needed for this derive. Note that #[derive(FromSqlRow)] will also generate a Queryable implementation.

Associated Constants

const FIELDS_NEEDED: usize

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

Loading content...

Required methods

fn build_from_row<T: Row<DB>>(row: &mut T) -> Result<Self>

See the trait documentation.

Loading content...

Implementations on Foreign Types

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Timespec where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Value where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for [u8; 6] where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for IpNetwork where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

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

fn build_from_row<R: Row<Pg>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<A, SA> FromSqlRow<Record<(SA,)>, Pg> for (A,) where
    Self: FromSql<Record<(SA,)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, SA, SB> FromSqlRow<Record<(SA, SB)>, Pg> for (A, B) where
    Self: FromSql<Record<(SA, SB)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, SA, SB, SC> FromSqlRow<Record<(SA, SB, SC)>, Pg> for (A, B, C) where
    Self: FromSql<Record<(SA, SB, SC)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, SA, SB, SC, SD> FromSqlRow<Record<(SA, SB, SC, SD)>, Pg> for (A, B, C, D) where
    Self: FromSql<Record<(SA, SB, SC, SD)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, SA, SB, SC, SD, SE> FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg> for (A, B, C, D, E, F) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg> for (A, B, C, D, E, F, G) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg> for (A, B, C, D, E, F, G, H) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg> for (A, B, C, D, E, F, G, H, I) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg> for (A, B, C, D, E, F, G, H, I, J) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

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> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<Pg>>(row: &mut RowT) -> Result<Self>

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Uuid where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for SystemTime where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for NaiveDate where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for NaiveTime where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for NaiveDateTime where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<Tz: TimeZone, __ST, __DB> FromSqlRow<__ST, __DB> for DateTime<Tz> where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for BigDecimal where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

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

const FIELDS_NEEDED: usize

fn build_from_row<R: Row<DB>>(row: &mut R) -> Result<Self>

impl<__ST, __DB> FromSqlRow<__ST, __DB> for bool where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for i8 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for i16 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for i32 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for i64 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for u8 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for u16 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for u32 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for u64 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for f32 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for f64 where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for String where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<T, __ST, __DB> FromSqlRow<__ST, __DB> for Vec<T> where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<'a, T: ?Sized, ST, DB> FromSqlRow<ST, DB> for Cow<'a, T> where
    T: 'a + ToOwned,
    DB: Backend,
    Cow<'a, T>: FromSql<ST, DB>, 

fn build_from_row<R: Row<DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

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

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

fn build_from_row<RowT: Row<__DB>>(
    row: &mut RowT
) -> Result<Self, Box<dyn 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>, 

const FIELDS_NEEDED: usize

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

Loading content...

Implementors

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgNumeric where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgMoney where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgDate where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgInterval where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgTime where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

impl<__ST, __DB> FromSqlRow<__ST, __DB> for PgTimestamp where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

const FIELDS_NEEDED: usize

Loading content...