[][src]Trait diesel::deserialize::FromSql

pub trait FromSql<A, DB: Backend>: Sized {
    fn from_sql(bytes: Option<RawValue<DB>>) -> Result<Self>;
}

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

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<backend::RawValue<DB>>) -> 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

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

See the trait documentation.

Loading content...

Implementations on Foreign Types

impl FromSql<Datetime, Mysql> for MYSQL_TIME[src]

impl FromSql<Timestamp, Mysql> for MYSQL_TIME[src]

impl FromSql<Time, Mysql> for MYSQL_TIME[src]

impl FromSql<Date, Mysql> for MYSQL_TIME[src]

impl FromSql<Datetime, Mysql> for NaiveDateTime[src]

impl FromSql<Timestamp, Mysql> for NaiveDateTime[src]

impl FromSql<Time, Mysql> for NaiveTime[src]

impl FromSql<Date, Mysql> for NaiveDate[src]

impl FromSql<Numeric, Mysql> for BigDecimal[src]

impl FromSql<TinyInt, Mysql> for i8[src]

impl FromSql<Unsigned<TinyInt>, Mysql> for u8[src]

impl FromSql<Unsigned<SmallInt>, Mysql> for u16[src]

impl FromSql<Unsigned<Integer>, Mysql> for u32[src]

impl FromSql<Unsigned<BigInt>, Mysql> for u64[src]

impl FromSql<Bool, Mysql> for bool[src]

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

impl FromSql<Timestamp, Pg> for NaiveDateTime[src]

impl FromSql<Timestamptz, Pg> for NaiveDateTime[src]

impl FromSql<Timestamptz, Pg> for DateTime<Utc>[src]

impl FromSql<Timestamptz, Pg> for DateTime<Local>[src]

impl FromSql<Time, Pg> for NaiveTime[src]

impl FromSql<Date, Pg> for NaiveDate[src]

impl FromSql<Timestamp, Pg> for Timespec[src]

impl FromSql<Timestamp, Pg> for SystemTime[src]

impl FromSql<Oid, Pg> for u32[src]

impl FromSql<Json, Pg> for Value[src]

impl FromSql<Jsonb, Pg> for Value[src]

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

impl FromSql<Inet, Pg> for IpNetwork[src]

impl FromSql<Cidr, Pg> for IpNetwork[src]

impl FromSql<Numeric, Pg> for BigDecimal[src]

impl FromSql<Bool, Pg> for bool[src]

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

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

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

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

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>, 
[src]

impl<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>, 
[src]

impl<A, 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>, 
[src]

impl<A, B, 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>, 
[src]

impl<A, B, C, 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>, 
[src]

impl<A, B, C, D, 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>, 
[src]

impl<A, B, C, D, E, 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>, 
[src]

impl<A, B, C, D, E, F, 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>, 
[src]

impl<A, B, C, D, E, F, G, 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>, 
[src]

impl<A, B, C, D, E, F, G, H, 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>, 
[src]

impl FromSql<Uuid, Pg> for Uuid[src]

impl FromSql<Date, Sqlite> for NaiveDate[src]

impl FromSql<Time, Sqlite> for NaiveTime[src]

impl FromSql<Timestamp, Sqlite> for NaiveDateTime[src]

impl FromSql<Date, Sqlite> for *const str[src]

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

impl FromSql<Time, Sqlite> for *const str[src]

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

impl FromSql<Timestamp, Sqlite> for *const str[src]

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

impl FromSql<Numeric, Sqlite> for BigDecimal[src]

impl FromSql<Text, Sqlite> for *const str[src]

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

impl FromSql<Binary, Sqlite> for *const [u8][src]

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

impl FromSql<SmallInt, Sqlite> for i16[src]

impl FromSql<Integer, Sqlite> for i32[src]

impl FromSql<Bool, Sqlite> for bool[src]

impl FromSql<BigInt, Sqlite> for i64[src]

impl FromSql<Float, Sqlite> for f32[src]

impl FromSql<Double, Sqlite> for f64[src]

impl<DB> FromSql<Float, DB> for f32 where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

impl<DB> FromSql<Double, DB> for f64 where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

impl<DB> FromSql<SmallInt, DB> for i16 where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

impl<DB> FromSql<Integer, DB> for i32 where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

impl<DB> FromSql<BigInt, DB> for i64 where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

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

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

impl<DB> FromSql<Text, DB> for *const str where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

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

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

impl<DB> FromSql<Binary, DB> for *const [u8] where
    DB: Backend + for<'a> BinaryRawValue<'a>, 
[src]

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

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

Loading content...

Implementors

impl FromSql<Money, Pg> for PgMoney[src]

impl FromSql<Timestamptz, Pg> for PgTimestamp[src]

impl FromSql<Date, Pg> for PgDate[src]

impl FromSql<Interval, Pg> for PgInterval[src]

impl FromSql<Numeric, Pg> for PgNumeric[src]

impl FromSql<Time, Pg> for PgTime[src]

impl FromSql<Timestamp, Pg> for PgTimestamp[src]

Loading content...