Struct Pg

pub struct Pg;

The PostgreSQL backend

Trait Implementations

impl Backend for Pg

type QueryBuilder = PgQueryBuilder

The concrete QueryBuilder implementation for this backend.

type BindCollector = RawBytesBindCollector<Pg>

The concrete BindCollector implementation for this backend.

type RawValue = [u8]

The raw representation of a database value given to FromSql.

type ByteOrder = BigEndian

What byte order is used to transmit integers?

impl Clone for Pg

fn clone(&self) -> Pg

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pg

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, ST> FromSql<Array<ST>, Pg> for Vec<T>

where T: FromSql<ST, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Bool, Pg> for bool

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Cidr, Pg> for IpNetwork

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Date, Pg> for NaiveDate

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Date, Pg> for PgDate

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Inet, Pg> for IpNetwork

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Interval, Pg> for PgInterval

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Json, Pg> for Value

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Jsonb, Pg> for Value

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<MacAddr, Pg> for [u8; 6]

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Money, Pg> for PgMoney

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Numeric, Pg> for PgNumeric

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Oid, Pg> for u32

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where T: FromSql<ST, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>, D: FromSql<SD, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>, F: FromSql<SF, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>, F: FromSql<SF, Pg>, G: FromSql<SG, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

where A: FromSql<SA, Pg>, B: FromSql<SB, Pg>, C: FromSql<SC, Pg>, D: FromSql<SD, Pg>, E: FromSql<SE, Pg>, F: FromSql<SF, Pg>, G: FromSql<SG, Pg>, H: FromSql<SH, Pg>,

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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> FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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)

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

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Time, Pg> for NaiveTime

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Time, Pg> for PgTime

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamp, Pg> for NaiveDateTime

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamp, Pg> for PgTimestamp

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamp, Pg> for SystemTime

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamptz, Pg> for DateTime<Utc>

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamptz, Pg> for NaiveDateTime

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Timestamptz, Pg> for PgTimestamp

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Uuid, Pg> for Uuid

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl FromSql<Uuid, Pg> for Uuid

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

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

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

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

See the trait documentation.

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

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

where Self: FromSql<Record<(SA,)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB)>, Pg>,

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

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

See the trait documentation.

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

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE)>, Pg>,

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

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

See the trait documentation.

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

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, SAG, SAH, SAI, SAJ, SAK, SAL, SAM, SAN, SAO, SAP, SAQ, SAR, SAS, SAT, SAU, SAV, SAW, SAX, SAY, SAZ, SBA, SBB, SBC)>, Pg>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

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)

where Self: FromSql<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, 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>,

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

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

See the trait documentation.

impl<T> HasSqlType<Array<T>> for Pg

where Pg: HasSqlType<T>,

fn metadata(lookup: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<BigInt> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Binary> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Bool> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Cidr> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Date> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Double> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Float> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Inet> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Integer> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Interval> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Json> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Jsonb> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<MacAddr> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Money> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Numeric> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Oid> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<BigInt>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<Date>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<Integer>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<Numeric>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<Timestamp>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Range<Timestamptz>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl<ST> HasSqlType<Record<ST>> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<SmallInt> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Text> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Time> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Timestamp> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Timestamptz> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl HasSqlType<Uuid> for Pg

fn metadata(_: &PgMetadataLookup) -> PgTypeMetadata

Fetch the metadata for the given type

impl Hash for Pg

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Pg

fn eq(&self, other: &Pg) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl QueryBuilder<Pg> for PgQueryBuilder

fn push_sql(&mut self, sql: &str)

Add sql to the end of the query being constructed.

fn push_identifier(&mut self, identifier: &str) -> QueryResult<()>

Quote identifier, and add it to the end of the query being constructed.

fn push_bind_param(&mut self)

Add a placeholder for a bind parameter to the end of the query being constructed.

fn finish(self) -> String

Returns the constructed SQL query.

impl<T> QueryFragment<Pg> for DistinctOnClause<T>

where T: QueryFragment<Pg>,

fn walk_ast(&self, out: AstPass<'_, Pg>) -> QueryResult<()>

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>

Converts this QueryFragment to its SQL representation.

fn collect_binds( &self, out: &mut DB::BindCollector, metadata_lookup: &DB::MetadataLookup, ) -> QueryResult<()>

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>

Is this query safe to store in the prepared statement cache?

impl<'a> QueryFragment<Pg> for TransactionBuilder<'a>

fn walk_ast(&self, out: AstPass<'_, Pg>) -> QueryResult<()>

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>

Converts this QueryFragment to its SQL representation.

fn collect_binds( &self, out: &mut DB::BindCollector, metadata_lookup: &DB::MetadataLookup, ) -> QueryResult<()>

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>

Is this query safe to store in the prepared statement cache?

impl Queryable<(Oid, Oid), Pg> for PgTypeMetadata

type Row = (u32, u32)

The Rust type you’d like to map from.

fn build((oid, array_oid): Self::Row) -> Self

Construct an instance of this type

impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>)

where T: FromSql<ST, Pg> + Queryable<ST, Pg>,

type Row = (Bound<T>, Bound<T>)

The Rust type you’d like to map from.

fn build(row: Self) -> Self

Construct an instance of this type

impl<A, SA> Queryable<Record<(SA,)>, Pg> for (A,)

where Self: FromSqlRow<Record<(SA,)>, Pg>,

type Row = (A,)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl<A, B, SA, SB> Queryable<Record<(SA, SB)>, Pg> for (A, B)

where Self: FromSqlRow<Record<(SA, SB)>, Pg>,

type Row = (A, B)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl<A, B, C, SA, SB, SC> Queryable<Record<(SA, SB, SC)>, Pg> for (A, B, C)

where Self: FromSqlRow<Record<(SA, SB, SC)>, Pg>,

type Row = (A, B, C)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD)>, Pg>,

type Row = (A, B, C, D)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE)>, Pg>,

type Row = (A, B, C, D, E)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF)>, Pg>,

type Row = (A, B, C, D, E, F)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG)>, Pg>,

type Row = (A, B, C, D, E, F, G)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH)>, Pg>,

type Row = (A, B, C, D, E, F, G, H)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: FromSqlRow<Record<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU)>, Pg>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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> Queryable<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)

where Self: 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>,

type Row = (A, B, 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)

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl<ST, T> ToSql<Array<ST>, Pg> for [T]

where Pg: HasSqlType<ST>, T: ToSql<ST, Pg>,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<ST, T> ToSql<Array<ST>, Pg> for Vec<T>

where [T]: ToSql<Array<ST>, Pg>, T: Debug,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Bool, Pg> for bool

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Cidr, Pg> for IpNetwork

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Date, Pg> for NaiveDate

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Date, Pg> for PgDate

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Inet, Pg> for IpNetwork

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Interval, Pg> for PgInterval

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Json, Pg> for Value

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Jsonb, Pg> for Value

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<MacAddr, Pg> for [u8; 6]

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Money, Pg> for PgMoney

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for [T]

where [T]: ToSql<Array<ST>, Pg>,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for Vec<T>

where Vec<T>: ToSql<Array<ST>, Pg>,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<ST, T> ToSql<Nullable<Range<ST>>, Pg> for (Bound<T>, Bound<T>)

where (Bound<T>, Bound<T>): ToSql<Range<ST>, Pg>,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Numeric, Pg> for PgNumeric

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Oid, Pg> for u32

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<ST, T> ToSql<Range<ST>, Pg> for (Bound<T>, Bound<T>)

where T: ToSql<ST, Pg>,

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Time, Pg> for NaiveTime

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Time, Pg> for PgTime

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Timestamp, Pg> for NaiveDateTime

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Timestamp, Pg> for PgTimestamp

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Timestamp, Pg> for SystemTime

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<TZ: TimeZone> ToSql<Timestamptz, Pg> for DateTime<TZ>

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Timestamptz, Pg> for NaiveDateTime

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Timestamptz, Pg> for PgTimestamp

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Uuid, Pg> for Uuid

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl ToSql<Uuid, Pg> for Uuid

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl TypeMetadata for Pg

type TypeMetadata = PgTypeMetadata

The actual type used to represent metadata.

type MetadataLookup = PgMetadataLookup

The type used for runtime lookup of metadata.

impl Copy for Pg

impl Eq for Pg

impl StructuralPartialEq for Pg

impl SupportsDefaultKeyword for Pg

impl SupportsReturningClause for Pg

impl UsesAnsiSavepointSyntax for Pg