Trait diesel::deserialize::FromStaticSqlRow[][src]

pub trait FromStaticSqlRow<ST, DB: Backend>: Sized {
    fn build_from_row<'a>(row: &impl Row<'a, DB>) -> Result<Self>;
}

A helper trait to deserialize a statically sized row into an tuple

If you see an error message mentioning this trait you likly trying to map the result of an query to an struct with missmatching field types. Recheck your field order and the concrete field types

You should not need to implement this trait directly. Diesel provides wild card implementations for any supported tuple size and for any type that implements FromSql<ST, DB>.

Required methods

fn build_from_row<'a>(row: &impl Row<'a, DB>) -> Result<Self>[src]

See the trait documentation

Loading content...

Implementations on Foreign Types

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

impl<__T, SA, __DB> FromStaticSqlRow<Nullable<(SA,)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA,): SqlType,
    __T: FromSqlRow<(SA,), __DB>, 
[src]

impl<A, SA, B, SB, __DB> FromStaticSqlRow<(SB, SA), __DB> for (B, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, __DB> FromStaticSqlRow<Nullable<(SA, SB)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB): SqlType,
    __T: FromSqlRow<(SA, SB), __DB>, 
[src]

impl<A, SA, B, C, SB, SC, __DB> FromStaticSqlRow<(SB, SC, SA), __DB> for (B, C, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC): SqlType,
    __T: FromSqlRow<(SA, SB, SC), __DB>, 
[src]

impl<A, SA, B, C, D, SB, SC, SD, __DB> FromStaticSqlRow<(SB, SC, SD, SA), __DB> for (B, C, D, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD), __DB>, 
[src]

impl<A, SA, B, C, D, E, SB, SC, SD, SE, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SA), __DB> for (B, C, D, E, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, SB, SC, SD, SE, SF, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SA), __DB> for (B, C, D, E, F, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, SB, SC, SD, SE, SF, SG, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SA), __DB> for (B, C, D, E, F, G, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, SB, SC, SD, SE, SF, SG, SH, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SA), __DB> for (B, C, D, E, F, G, H, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, SB, SC, SD, SE, SF, SG, SH, SI, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SA), __DB> for (B, C, D, E, F, G, H, I, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, SB, SC, SD, SE, SF, SG, SH, SI, SJ, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SA), __DB> for (B, C, D, E, F, G, H, I, J, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, __DB> FromStaticSqlRow<Nullable<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, __DB> for Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV): SqlType,
    __T: FromSqlRow<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV), __DB>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>, 
[src]

impl<__T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, __DB> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW): SqlType,
    __T: 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>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, __DB> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>,
    SX: CompatibleType<X, __DB>,
    X: FromSqlRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB> + StaticallySizedRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB>, 
[src]

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX): SqlType,
    __T: 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>, 
[src]

impl<A, SA, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, 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> FromStaticSqlRow<(SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SA), __DB> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>,
    SX: CompatibleType<X, __DB>,
    X: FromSqlRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB> + StaticallySizedRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB>,
    SY: CompatibleType<Y, __DB>,
    Y: FromSqlRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB> + StaticallySizedRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB>, 
[src]

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

impl<A, SA, 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, 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> FromStaticSqlRow<(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, SA), __DB> for (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, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>,
    SX: CompatibleType<X, __DB>,
    X: FromSqlRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB> + StaticallySizedRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB>,
    SY: CompatibleType<Y, __DB>,
    Y: FromSqlRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB> + StaticallySizedRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB>,
    SZ: CompatibleType<Z, __DB>,
    Z: FromSqlRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB> + StaticallySizedRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB>, 
[src]

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

impl<A, SA, 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, 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> FromStaticSqlRow<(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, SA), __DB> for (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, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>,
    SX: CompatibleType<X, __DB>,
    X: FromSqlRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB> + StaticallySizedRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB>,
    SY: CompatibleType<Y, __DB>,
    Y: FromSqlRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB> + StaticallySizedRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB>,
    SZ: CompatibleType<Z, __DB>,
    Z: FromSqlRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB> + StaticallySizedRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB>,
    SAA: CompatibleType<AA, __DB>,
    AA: FromSqlRow<<SAA as CompatibleType<AA, __DB>>::SqlType, __DB> + StaticallySizedRow<<SAA as CompatibleType<AA, __DB>>::SqlType, __DB>, 
[src]

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

impl<A, SA, 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, 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> FromStaticSqlRow<(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, SA), __DB> for (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, A) where
    __DB: Backend,
    SA: CompatibleType<A, __DB>,
    A: FromSqlRow<<SA as CompatibleType<A, __DB>>::SqlType, __DB>,
    SB: CompatibleType<B, __DB>,
    B: FromSqlRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB> + StaticallySizedRow<<SB as CompatibleType<B, __DB>>::SqlType, __DB>,
    SC: CompatibleType<C, __DB>,
    C: FromSqlRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB> + StaticallySizedRow<<SC as CompatibleType<C, __DB>>::SqlType, __DB>,
    SD: CompatibleType<D, __DB>,
    D: FromSqlRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB> + StaticallySizedRow<<SD as CompatibleType<D, __DB>>::SqlType, __DB>,
    SE: CompatibleType<E, __DB>,
    E: FromSqlRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB> + StaticallySizedRow<<SE as CompatibleType<E, __DB>>::SqlType, __DB>,
    SF: CompatibleType<F, __DB>,
    F: FromSqlRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB> + StaticallySizedRow<<SF as CompatibleType<F, __DB>>::SqlType, __DB>,
    SG: CompatibleType<G, __DB>,
    G: FromSqlRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB> + StaticallySizedRow<<SG as CompatibleType<G, __DB>>::SqlType, __DB>,
    SH: CompatibleType<H, __DB>,
    H: FromSqlRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB> + StaticallySizedRow<<SH as CompatibleType<H, __DB>>::SqlType, __DB>,
    SI: CompatibleType<I, __DB>,
    I: FromSqlRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB> + StaticallySizedRow<<SI as CompatibleType<I, __DB>>::SqlType, __DB>,
    SJ: CompatibleType<J, __DB>,
    J: FromSqlRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB> + StaticallySizedRow<<SJ as CompatibleType<J, __DB>>::SqlType, __DB>,
    SK: CompatibleType<K, __DB>,
    K: FromSqlRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB> + StaticallySizedRow<<SK as CompatibleType<K, __DB>>::SqlType, __DB>,
    SL: CompatibleType<L, __DB>,
    L: FromSqlRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB> + StaticallySizedRow<<SL as CompatibleType<L, __DB>>::SqlType, __DB>,
    SM: CompatibleType<M, __DB>,
    M: FromSqlRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB> + StaticallySizedRow<<SM as CompatibleType<M, __DB>>::SqlType, __DB>,
    SN: CompatibleType<N, __DB>,
    N: FromSqlRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB> + StaticallySizedRow<<SN as CompatibleType<N, __DB>>::SqlType, __DB>,
    SO: CompatibleType<O, __DB>,
    O: FromSqlRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB> + StaticallySizedRow<<SO as CompatibleType<O, __DB>>::SqlType, __DB>,
    SP: CompatibleType<P, __DB>,
    P: FromSqlRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB> + StaticallySizedRow<<SP as CompatibleType<P, __DB>>::SqlType, __DB>,
    SQ: CompatibleType<Q, __DB>,
    Q: FromSqlRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB> + StaticallySizedRow<<SQ as CompatibleType<Q, __DB>>::SqlType, __DB>,
    SR: CompatibleType<R, __DB>,
    R: FromSqlRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB> + StaticallySizedRow<<SR as CompatibleType<R, __DB>>::SqlType, __DB>,
    SS: CompatibleType<S, __DB>,
    S: FromSqlRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB> + StaticallySizedRow<<SS as CompatibleType<S, __DB>>::SqlType, __DB>,
    ST: CompatibleType<T, __DB>,
    T: FromSqlRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB> + StaticallySizedRow<<ST as CompatibleType<T, __DB>>::SqlType, __DB>,
    SU: CompatibleType<U, __DB>,
    U: FromSqlRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB> + StaticallySizedRow<<SU as CompatibleType<U, __DB>>::SqlType, __DB>,
    SV: CompatibleType<V, __DB>,
    V: FromSqlRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB> + StaticallySizedRow<<SV as CompatibleType<V, __DB>>::SqlType, __DB>,
    SW: CompatibleType<W, __DB>,
    W: FromSqlRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB> + StaticallySizedRow<<SW as CompatibleType<W, __DB>>::SqlType, __DB>,
    SX: CompatibleType<X, __DB>,
    X: FromSqlRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB> + StaticallySizedRow<<SX as CompatibleType<X, __DB>>::SqlType, __DB>,
    SY: CompatibleType<Y, __DB>,
    Y: FromSqlRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB> + StaticallySizedRow<<SY as CompatibleType<Y, __DB>>::SqlType, __DB>,
    SZ: CompatibleType<Z, __DB>,
    Z: FromSqlRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB> + StaticallySizedRow<<SZ as CompatibleType<Z, __DB>>::SqlType, __DB>,
    SAA: CompatibleType<AA, __DB>,
    AA: FromSqlRow<<SAA as CompatibleType<AA, __DB>>::SqlType, __DB> + StaticallySizedRow<<SAA as CompatibleType<AA, __DB>>::SqlType, __DB>,
    SAB: CompatibleType<AB, __DB>,
    AB: FromSqlRow<<SAB as CompatibleType<AB, __DB>>::SqlType, __DB> + StaticallySizedRow<<SAB as CompatibleType<AB, __DB>>::SqlType, __DB>, 
[src]

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

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

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

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

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

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

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

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

impl<__T, 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> FromStaticSqlRow<Nullable<(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 Option<__T> where
    __DB: Backend,
    (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): SqlType,
    __T: 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>, 
[src]

Loading content...

Implementors

impl<T, ST, DB> FromStaticSqlRow<ST, DB> for T where
    DB: Backend,
    T: FromSql<ST, DB>,
    ST: SingleValue
[src]

Loading content...