diesel::deserialize

Trait FromSqlRow

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

    // Required method
    fn build_from_row<T: Row<DB>>(row: &mut T) -> Result<Self>;
}
Expand description

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.

Provided Associated Constants§

Source

const FIELDS_NEEDED: usize = 1usize

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

Required Methods§

Source

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

See the trait documentation.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

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

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, SBL), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>, BH: FromSqlRow<SBH, __DB>, BI: FromSqlRow<SBI, __DB>, BJ: FromSqlRow<SBJ, __DB>, BK: FromSqlRow<SBK, __DB>, BL: FromSqlRow<SBL, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, SBK), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>, BH: FromSqlRow<SBH, __DB>, BI: FromSqlRow<SBI, __DB>, BJ: FromSqlRow<SBJ, __DB>, BK: FromSqlRow<SBK, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, SBJ), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>, BH: FromSqlRow<SBH, __DB>, BI: FromSqlRow<SBI, __DB>, BJ: FromSqlRow<SBJ, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, SBI), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>, BH: FromSqlRow<SBH, __DB>, BI: FromSqlRow<SBI, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, SBH), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>, BH: FromSqlRow<SBH, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, SBG), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>, BG: FromSqlRow<SBG, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, SBF), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, BF)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>, BF: FromSqlRow<SBF, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, SBE), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, BE)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>, BE: FromSqlRow<SBE, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, SBD), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, BD)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>, BD: FromSqlRow<SBD, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, BC)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>, BC: FromSqlRow<SBC, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, BB)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>, BB: FromSqlRow<SBB, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, BA)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>, BA: FromSqlRow<SBA, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>, AZ: FromSqlRow<SAZ, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>, AY: FromSqlRow<SAY, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>, AX: FromSqlRow<SAX, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>, AW: FromSqlRow<SAW, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>, AV: FromSqlRow<SAV, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>, AU: FromSqlRow<SAU, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>, AT: FromSqlRow<SAT, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>, AS: FromSqlRow<SAS, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>, AR: FromSqlRow<SAR, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>, AQ: FromSqlRow<SAQ, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>, AP: FromSqlRow<SAP, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO), __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, AG, AH, AI, AJ, AK, AL, AM, AN, AO)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>, AO: FromSqlRow<SAO, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN)>, 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, AG, AH, AI, AJ, AK, AL, AM, AN)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, AN, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, __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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN), __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, AG, AH, AI, AJ, AK, AL, AM, AN)
where __DB: Backend, A: FromSqlRow<SA, __DB>, B: FromSqlRow<SB, __DB>, C: FromSqlRow<SC, __DB>, D: FromSqlRow<SD, __DB>, E: FromSqlRow<SE, __DB>, F: FromSqlRow<SF, __DB>, G: FromSqlRow<SG, __DB>, H: FromSqlRow<SH, __DB>, I: FromSqlRow<SI, __DB>, J: FromSqlRow<SJ, __DB>, K: FromSqlRow<SK, __DB>, L: FromSqlRow<SL, __DB>, M: FromSqlRow<SM, __DB>, N: FromSqlRow<SN, __DB>, O: FromSqlRow<SO, __DB>, P: FromSqlRow<SP, __DB>, Q: FromSqlRow<SQ, __DB>, R: FromSqlRow<SR, __DB>, S: FromSqlRow<SS, __DB>, T: FromSqlRow<ST, __DB>, U: FromSqlRow<SU, __DB>, V: FromSqlRow<SV, __DB>, W: FromSqlRow<SW, __DB>, X: FromSqlRow<SX, __DB>, Y: FromSqlRow<SY, __DB>, Z: FromSqlRow<SZ, __DB>, AA: FromSqlRow<SAA, __DB>, AB: FromSqlRow<SAB, __DB>, AC: FromSqlRow<SAC, __DB>, AD: FromSqlRow<SAD, __DB>, AE: FromSqlRow<SAE, __DB>, AF: FromSqlRow<SAF, __DB>, AG: FromSqlRow<SAG, __DB>, AH: FromSqlRow<SAH, __DB>, AI: FromSqlRow<SAI, __DB>, AJ: FromSqlRow<SAJ, __DB>, AK: FromSqlRow<SAK, __DB>, AL: FromSqlRow<SAL, __DB>, AM: FromSqlRow<SAM, __DB>, AN: FromSqlRow<SAN, __DB>,

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, AM, 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM> 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, SAG, SAH, SAI, SAJ, SAK, SAL, SAM)>, 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, AG, AH, AI, AJ, AK, AL, AM)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, AL, 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, SAG, SAH, SAI, SAJ, SAK, SAL> 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, SAG, SAH, SAI, SAJ, SAK, SAL)>, 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, AG, AH, AI, AJ, AK, AL)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, AK, 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, SAG, SAH, SAI, SAJ, SAK> 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, SAG, SAH, SAI, SAJ, SAK)>, 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, AG, AH, AI, AJ, AK)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, AJ, 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, SAG, SAH, SAI, SAJ> 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, SAG, SAH, SAI, SAJ)>, 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, AG, AH, AI, AJ)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, AI, 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, SAG, SAH, SAI> 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, SAG, SAH, SAI)>, 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, AG, AH, AI)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, AH, 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, SAG, SAH> 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, SAG, SAH)>, 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, AG, AH)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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, AG, 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, SAG> 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, SAG)>, 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, AG)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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)

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize = 1usize

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize

Source§

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

Source§

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

Source§

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

Source§

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

Source§

const FIELDS_NEEDED: usize = T::FIELDS_NEEDED

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Implementors§

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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