Trait block_tools::db::use_diesel::deserialize::FromSql[−][src]

pub trait FromSql<A, DB> where
    DB: Backend, {
    pub fn from_sql(
        bytes: Option<&<DB as Backend>::RawValue>
    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync, Global>>;
}

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

pub fn from_sql(
    bytes: Option<&<DB as Backend>::RawValue>
) -> Result<Self, Box<dyn Error + 'static + Send + Sync, Global>>[src]

See the trait documentation.

Loading content...

Implementations on Foreign Types

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

impl FromSql<Date, Pg> for NaiveDate[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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    G: FromSql<SG, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    I: FromSql<SI, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>, [src]

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

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

impl<T, ST, DB> FromSql<Nullable<ST>, DB> for Option<T> where
    DB: Backend,
    ST: NotNull,
    T: FromSql<ST, DB>, [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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, 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, 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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, 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<ST, DB> FromSql<ST, DB> for Vec<u8, Global> where
    DB: Backend,
    *const [u8]: FromSql<ST, DB>, [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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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, 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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>, [src]

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

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

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

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

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

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

impl<DB> FromSql<Double, DB> for f64 where
    DB: Backend<RawValue = [u8]>, [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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, 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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    B: FromSql<SB, 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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, Pg>, [src]

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

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

impl<DB> FromSql<SmallInt, DB> for i16 where
    DB: Backend<RawValue = [u8]>, [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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, 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, 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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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, T, ST, DB> FromSql<ST, DB> for Cow<'a, T> where
    DB: Backend,
    T: 'a + ToOwned + ?Sized,
    <T as ToOwned>::Owned: FromSql<ST, DB>, [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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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, SA, SB, SC, SD, SE> FromSql<Record<(SA, SB, SC, SD, SE)>, Pg> for (A, B, C, D, E) where
    C: FromSql<SC, Pg>,
    D: FromSql<SD, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    B: FromSql<SB, Pg>, [src]

impl<DB> FromSql<Float, DB> for f32 where
    DB: Backend<RawValue = [u8]>, [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
    C: FromSql<SC, Pg>,
    S: FromSql<SS, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    W: FromSql<SW, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    T: FromSql<ST, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    U: FromSql<SU, Pg>,
    P: FromSql<SP, Pg>,
    A: FromSql<SA, Pg>,
    R: FromSql<SR, Pg>,
    K: FromSql<SK, Pg>,
    V: FromSql<SV, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>,
    Q: FromSql<SQ, 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, 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
    C: FromSql<SC, Pg>,
    F: FromSql<SF, Pg>,
    D: FromSql<SD, Pg>,
    O: FromSql<SO, Pg>,
    L: FromSql<SL, Pg>,
    G: FromSql<SG, Pg>,
    M: FromSql<SM, Pg>,
    E: FromSql<SE, Pg>,
    A: FromSql<SA, Pg>,
    K: FromSql<SK, Pg>,
    I: FromSql<SI, Pg>,
    N: FromSql<SN, Pg>,
    B: FromSql<SB, Pg>,
    H: FromSql<SH, Pg>,
    J: FromSql<SJ, Pg>, [src]

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

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