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, SA, SB, SC, 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 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>

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