Trait diesel::deserialize::FromSqlRow[][src]

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

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

See the trait documentation.

Implementations on Foreign Types

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

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

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

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

impl<T, ST> FromSqlRow<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
    (Bound<T>, Bound<T>): FromSql<Range<ST>, Pg>, 
[src]

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

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

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>, 
[src]

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

impl<A, B, SA, SB, __DB> FromSqlRow<(SA, SB), __DB> for (A, B) where
    __DB: Backend,
    A: FromSqlRow<SA, __DB>,
    B: FromSqlRow<SB, __DB>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

Implementors