Trait block_tools::db::use_diesel::deserialize::FromSqlRow

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

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

Deserialize one or more fields.

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

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

Deriving

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

Associated Constants

pub const FIELDS_NEEDED: usize

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

Loading content...

Required methods

pub fn build_from_row<T>(
    row: &mut T
) -> Result<Self, Box<dyn Error + 'static + Send + Sync, Global>> where
    T: Row<DB>, 

See the trait documentation.

Loading content...

Implementations on Foreign Types

impl<A, B, C, D, E, SA, SB, SC, SD, SE, __DB> FromSqlRow<(SA, SB, SC, SD, SE), __DB> for (A, B, C, D, E) where
    C: FromSqlRow<SC, __DB>,
    __DB: Backend,
    D: FromSqlRow<SD, __DB>,
    E: FromSqlRow<SE, __DB>,
    A: FromSqlRow<SA, __DB>,
    B: FromSqlRow<SB, __DB>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<bool, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<u16, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<NaiveTime, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

impl<A, B, C, D, SA, SB, SC, SD, __DB> FromSqlRow<(SA, SB, SC, SD), __DB> for (A, B, C, D) where
    C: FromSqlRow<SC, __DB>,
    __DB: Backend,
    D: FromSqlRow<SD, __DB>,
    A: FromSqlRow<SA, __DB>,
    B: FromSqlRow<SB, __DB>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<String, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<i64, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A,), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF, __DB> FromSqlRow<(SA, SB, SC, SD, SE, SF), __DB> for (A, B, C, D, E, F) where
    C: FromSqlRow<SC, __DB>,
    __DB: Backend,
    F: FromSqlRow<SF, __DB>,
    D: FromSqlRow<SD, __DB>,
    E: FromSqlRow<SE, __DB>,
    A: FromSqlRow<SA, __DB>,
    B: FromSqlRow<SB, __DB>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A,), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<Cow<'a, T>, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<SystemTime, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<i32, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<DateTime<Tz>, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<i8, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<Vec<T, Global>, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<NaiveDate, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<i16, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<(Bound<T>, Bound<T>), Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<u32, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

impl<A, B, C, SA, SB, SC, __DB> FromSqlRow<(SA, SB, SC), __DB> for (A, B, C) where
    C: FromSqlRow<SC, __DB>,
    __DB: Backend,
    A: FromSqlRow<SA, __DB>,
    B: FromSqlRow<SB, __DB>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<f32, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<u8, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<u64, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<f64, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<R>(
    row: &mut R
) -> Result<Option<T>, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<DB>, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST> FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T): FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>, 

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<Pg>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

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

pub const FIELDS_NEEDED: usize

pub fn build_from_row<RowT>(
    row: &mut RowT
) -> Result<(A, B, C, D, E, F, G, H), Box<dyn Error + 'static + Send + Sync, Global>> where
    RowT: Row<__DB>, 

Loading content...

Implementors

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgNumeric, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgMoney, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgDate, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgInterval, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgTime, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

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

pub fn build_from_row<R>(
    row: &mut R
) -> Result<PgTimestamp, Box<dyn Error + 'static + Send + Sync, Global>> where
    R: Row<__DB>, 

Loading content...