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

Required methods

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

See the trait documentation.

Implementations on Foreign Types

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>

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

const FIELDS_NEEDED: usize

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

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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>

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

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

const FIELDS_NEEDED: usize

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

Implementors

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

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

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

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

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

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