Trait diesel::deserialize::FromSql

pub trait FromSql<A, DB: Backend>: Sized {
    fn from_sql(bytes: Option<&DB::RawValue>) -> 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

• 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.

Required Methods

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

See the trait documentation.

Implementations on Foreign Types

impl FromSql<Datetime, Mysql> for MYSQL_TIME

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

impl FromSql<Timestamp, Mysql> for MYSQL_TIME

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

impl FromSql<Time, Mysql> for MYSQL_TIME

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

impl FromSql<Date, Mysql> for MYSQL_TIME

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

impl FromSql<Datetime, Mysql> for NaiveDateTime

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

impl FromSql<Timestamp, Mysql> for NaiveDateTime

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

impl FromSql<Time, Mysql> for NaiveTime

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

impl FromSql<Date, Mysql> for NaiveDate

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

impl FromSql<Tinyint, Mysql> for i8

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

impl FromSql<Unsigned<SmallInt>, Mysql> for u16

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

impl FromSql<Unsigned<Integer>, Mysql> for u32

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

impl FromSql<Unsigned<BigInt>, Mysql> for u64

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

impl FromSql<Bool, Mysql> for bool

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

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

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

impl FromSql<Timestamp, Pg> for NaiveDateTime

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

impl FromSql<Timestamptz, Pg> for NaiveDateTime

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

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

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

impl FromSql<Time, Pg> for NaiveTime

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

impl FromSql<Date, Pg> for NaiveDate

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

impl FromSql<Timestamp, Pg> for SystemTime

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

impl FromSql<Oid, Pg> for u32

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

impl FromSql<Bool, Pg> for bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl FromSql<Date, Sqlite> for NaiveDate

fn from_sql(value: Option<&<Sqlite as Backend>::RawValue>) -> Result<Self>

impl FromSql<Time, Sqlite> for NaiveTime

fn from_sql(value: Option<&<Sqlite as Backend>::RawValue>) -> Result<Self>

impl FromSql<Timestamp, Sqlite> for NaiveDateTime

fn from_sql(value: Option<&<Sqlite as Backend>::RawValue>) -> Result<Self>

impl FromSql<Date, Sqlite> 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

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Time, Sqlite> 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

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Timestamp, Sqlite> 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

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<VarChar, Sqlite> 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

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Binary, Sqlite> 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

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

impl FromSql<SmallInt, Sqlite> for i16

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Integer, Sqlite> for i32

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Bool, Sqlite> for bool

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<BigInt, Sqlite> for i64

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Float, Sqlite> for f32

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

impl FromSql<Double, Sqlite> for f64

fn from_sql(value: Option<&SqliteValue>) -> Result<Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Implementors

• impl FromSql<Timestamp, Pg> for PgTimestamp

• impl FromSql<Timestamptz, Pg> for PgTimestamp

• impl FromSql<Date, Pg> for PgDate

• impl FromSql<Time, Pg> for PgTime

• impl FromSql<Interval, Pg> for PgInterval

• impl FromSql<Numeric, Pg> for PgNumeric

• impl FromSql<Money, Pg> for PgMoney