diesel::deserialize

Trait FromSql

Source
pub trait FromSql<A, DB: Backend>: Sized {
    // Required method
    fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>;
}
Expand description

Deserialize a single field of a given SQL type.

When possible, implementations of this trait should prefer to use an existing implementation, rather than reading from bytes. (For example, if you are implementing this for an enum which is represented as an integer in the database, prefer i32::from_sql(bytes) over reading from bytes directly)

Types which implement this trait should also have #[derive(FromSqlRow)]

§Backend specific details

  • For PostgreSQL, the bytes will be sent using the binary protocol, not text.
  • For SQLite, the actual type of DB::RawValue is private API. All implementations of this trait must be written in terms of an existing primitive.
  • For MySQL, the value of bytes will depend on the return value of type_metadata for the given SQL type. See MysqlType for details.
  • For third party backends, consult that backend’s documentation.

§Examples

Most implementations of this trait will be defined in terms of an existing implementation.

#[repr(i32)]
#[derive(Debug, Clone, Copy)]
pub enum MyEnum {
    A = 1,
    B = 2,
}

impl<DB> FromSql<Integer, DB> for MyEnum
where
    DB: Backend,
    i32: FromSql<Integer, DB>,
{
    fn from_sql(bytes: Option<&DB::RawValue>) -> deserialize::Result<Self> {
        match i32::from_sql(bytes)? {
            1 => Ok(MyEnum::A),
            2 => Ok(MyEnum::B),
            x => Err(format!("Unrecognized variant {}", x).into()),
        }
    }
}

Required Methods§

Source

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

See the trait documentation.

Dyn Compatibility§

This trait is not dyn compatible.

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

Implementations on Foreign Types§

Source§

impl FromSql<Cidr, Pg> for IpNetwork

Source§

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

Source§

impl FromSql<Inet, Pg> for IpNetwork

Source§

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

Source§

impl FromSql<Json, Pg> for Value

Source§

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

Source§

impl FromSql<Jsonb, Pg> for Value

Source§

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

Source§

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

Source§

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

Source§

impl FromSql<Oid, Pg> for u32

Source§

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

Source§

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

Source§

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

Source§

impl FromSql<Timestamptz, Pg> for NaiveDateTime

Source§

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

Source§

impl FromSql<Uuid, Pg> for Uuid

Source§

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

Source§

impl FromSql<Uuid, Pg> for Uuid

Source§

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

Source§

impl FromSql<Bool, Pg> for bool

Source§

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

Source§

impl FromSql<Date, Pg> for NaiveDate

Source§

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

Source§

impl FromSql<Time, Pg> for NaiveTime

Source§

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

Source§

impl FromSql<Timestamp, Pg> for NaiveDateTime

Source§

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

Source§

impl FromSql<Timestamp, Pg> for SystemTime

Source§

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

Source§

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

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> 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>,

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<BigInt, DB> for i64

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<Binary, DB> for *const [u8]

The returned pointer is only valid for the lifetime to the argument of from_sql. This impl is intended for uses where you want to write a new impl in terms of Vec<u8>, but don’t want to allocate. We have to return a raw pointer instead of a reference with a lifetime due to the structure of FromSql

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<Double, DB> for f64

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<Float, DB> for f32

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<Integer, DB> for i32

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<SmallInt, DB> for i16

Source§

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

Source§

impl<DB: Backend<RawValue = [u8]>> FromSql<Text, DB> for *const str

The returned pointer is only valid for the lifetime to the argument of from_sql. This impl is intended for uses where you want to write a new impl in terms of String, but don’t want to allocate. We have to return a raw pointer instead of a reference with a lifetime due to the structure of FromSql

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Source§

impl<ST, DB> FromSql<ST, DB> for String
where DB: Backend, *const str: FromSql<ST, DB>,

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Source§

impl<ST, DB> FromSql<ST, DB> for Vec<u8>
where DB: Backend, *const [u8]: FromSql<ST, DB>,

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self>

Implementors§