Trait sqlx::Decode

pub trait Decode<'r, DB> where
    DB: Database, {
    fn decode(
        value: <DB as HasValueRef<'r>>::ValueRef
    ) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>;
}

A type that can be decoded from the database.

How can I implement Decode?

A manual implementation of Decode can be useful when adding support for types externally to SQLx.

The following showcases how to implement Decode to be generic over Database. The implementation can be marginally simpler if you remove the DB type parameter and explicitly use the concrete ValueRef and TypeInfo types.

struct MyType;

// DB is the database driver
// `'r` is the lifetime of the `Row` being decoded
impl<'r, DB: Database> Decode<'r, DB> for MyType
where
    // we want to delegate some of the work to string decoding so let's make sure strings
    // are supported by the database
    &'r str: Decode<'r, DB>
{
    fn decode(
        value: <DB as HasValueRef<'r>>::ValueRef,
    ) -> Result<MyType, Box<dyn Error + 'static + Send + Sync>> {
        // the interface of ValueRef is largely unstable at the moment
        // so this is not directly implementable

        // however, you can delegate to a type that matches the format of the type you want
        // to decode (such as a UTF-8 string)

        let value = <&str as Decode<DB>>::decode(value)?;

        // now you can parse this into your type (assuming there is a `FromStr`)

        Ok(value.parse()?)
    }
}

Required methods

fn decode(
    value: <DB as HasValueRef<'r>>::ValueRef
) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

Decode a new value of this type using a raw value from the database.

Loading content...

Implementations on Foreign Types

impl<'r> Decode<'r, Sqlite> for f64

fn decode(
    value: SqliteValueRef<'r>
) -> Result<f64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for bool

fn decode(
    value: SqliteValueRef<'r>
) -> Result<bool, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for i64

fn decode(
    value: PgValueRef<'_>
) -> Result<i64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for &'r str where
    &'r str: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<&'r str, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4> Decode<'r, Postgres> for (T1, T2, T3, T4) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4), Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4, T5, T6, T7, T8> Decode<'r, Postgres> for (T1, T2, T3, T4, T5, T6, T7, T8) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T5: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T6: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T7: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T8: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for &'r str

fn decode(
    value: PgValueRef<'r>
) -> Result<&'r str, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for i8

fn decode(
    value: SqliteValueRef<'r>
) -> Result<i8, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for f64

fn decode(
    value: MySqlValueRef<'_>
) -> Result<f64, Box<dyn Error + 'static + Sync + Send>>

impl<'r, DB, T> Decode<'r, DB> for Option<T> where
    DB: Database,
    T: Decode<'r, DB>, 

fn decode(
    value: <DB as HasValueRef<'r>>::ValueRef
) -> Result<Option<T>, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for i8

fn decode(
    value: MssqlValueRef<'_>
) -> Result<i8, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for f64

fn decode(
    value: PgValueRef<'_>
) -> Result<f64, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for f32

fn decode(
    value: MssqlValueRef<'_>
) -> Result<f32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for i16

fn decode(
    value: PgValueRef<'_>
) -> Result<i16, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for String

fn decode(
    value: MySqlValueRef<'_>
) -> Result<String, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for bool where
    bool: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<bool, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for Vec<u8>

fn decode(
    value: MySqlValueRef<'_>
) -> Result<Vec<u8>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for &'r [u8]

fn decode(
    value: MySqlValueRef<'r>
) -> Result<&'r [u8], Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for Vec<u8>

fn decode(
    value: SqliteValueRef<'r>
) -> Result<Vec<u8>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for i32

fn decode(
    value: SqliteValueRef<'r>
) -> Result<i32, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3> Decode<'r, Postgres> for (T1, T2, T3) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for i16

fn decode(
    value: SqliteValueRef<'r>
) -> Result<i16, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for &'r str

fn decode(
    value: MySqlValueRef<'r>
) -> Result<&'r str, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for i32

fn decode(
    value: MssqlValueRef<'_>
) -> Result<i32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for i16

fn decode(
    value: MySqlValueRef<'_>
) -> Result<i16, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for Vec<u8>

fn decode(
    value: PgValueRef<'_>
) -> Result<Vec<u8>, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for i8

fn decode(
    value: PgValueRef<'_>
) -> Result<i8, Box<dyn Error + 'static + Sync + Send>>

impl<'r, DB> Decode<'r, DB> for Value where
    DB: Database,
    Value: Type<DB>,
    Json<Value>: Decode<'r, DB>, 

fn decode(
    value: <DB as HasValueRef<'r>>::ValueRef
) -> Result<Value, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for f32

fn decode(
    value: MySqlValueRef<'_>
) -> Result<f32, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for String

fn decode(
    value: SqliteValueRef<'r>
) -> Result<String, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for i16

fn decode(
    value: MssqlValueRef<'_>
) -> Result<i16, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1> Decode<'r, Postgres> for (T1,) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1,), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for f64 where
    f64: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<f64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for &'r [u8]

fn decode(
    value: SqliteValueRef<'r>
) -> Result<&'r [u8], Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for f32

fn decode(
    value: PgValueRef<'_>
) -> Result<f32, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for i64

fn decode(
    value: SqliteValueRef<'r>
) -> Result<i64, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for u32

fn decode(
    value: MySqlValueRef<'_>
) -> Result<u32, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for ()

fn decode(
    _value: PgValueRef<'r>
) -> Result<(), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for f32

fn decode(
    value: SqliteValueRef<'r>
) -> Result<f32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for i32

fn decode(
    value: PgValueRef<'_>
) -> Result<i32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for u16

fn decode(
    value: MySqlValueRef<'_>
) -> Result<u16, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for bool

fn decode(
    value: PgValueRef<'_>
) -> Result<bool, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for String

fn decode(
    value: PgValueRef<'_>
) -> Result<String, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for u32

fn decode(
    value: PgValueRef<'_>
) -> Result<u32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for i64

fn decode(
    value: MySqlValueRef<'_>
) -> Result<i64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for &'r [u8]

fn decode(
    value: PgValueRef<'r>
) -> Result<&'r [u8], Box<dyn Error + 'static + Sync + Send>>

impl<'r, DB> Decode<'r, DB> for &'r RawValue where
    DB: Database,
    &'r RawValue: Type<DB>,
    Json<&'r RawValue>: Decode<'r, DB>, 

fn decode(
    value: <DB as HasValueRef<'r>>::ValueRef
) -> Result<&'r RawValue, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4, T5, T6> Decode<'r, Postgres> for (T1, T2, T3, T4, T5, T6) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T5: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T6: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4, T5, T6), Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for i64

fn decode(
    value: MssqlValueRef<'_>
) -> Result<i64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for i64 where
    i64: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<i64, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for &'r str

fn decode(
    value: SqliteValueRef<'r>
) -> Result<&'r str, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for i32 where
    i32: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<i32, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for f32 where
    f32: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<f32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for bool

fn decode(
    value: MySqlValueRef<'_>
) -> Result<bool, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for i32

fn decode(
    value: MySqlValueRef<'_>
) -> Result<i32, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for f64

fn decode(
    value: MssqlValueRef<'_>
) -> Result<f64, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4, T5> Decode<'r, Postgres> for (T1, T2, T3, T4, T5) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T5: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4, T5), Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Any> for String where
    String: AnyDecode<'r>, 

fn decode(
    value: AnyValueRef<'r>
) -> Result<String, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for String

fn decode(
    value: MssqlValueRef<'_>
) -> Result<String, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for u8

fn decode(
    value: MySqlValueRef<'_>
) -> Result<u8, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4, T5, T6, T7, T8, T9> Decode<'r, Postgres> for (T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T5: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T6: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T7: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T8: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T9: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9), Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for i8

fn decode(
    value: MySqlValueRef<'_>
) -> Result<i8, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T1, T2, T3, T4, T5, T6, T7> Decode<'r, Postgres> for (T1, T2, T3, T4, T5, T6, T7) where
    T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T5: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T6: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,
    T7: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<(T1, T2, T3, T4, T5, T6, T7), Box<dyn Error + 'static + Sync + Send>>

impl<'r, T> Decode<'r, Postgres> for Vec<T> where
    T: for<'a> Decode<'a, Postgres> + Type<Postgres>,
    Vec<T>: Type<Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<Vec<T>, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for u64

fn decode(
    value: MySqlValueRef<'_>
) -> Result<u64, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Mssql> for bool

fn decode(
    value: MssqlValueRef<'_>
) -> Result<bool, Box<dyn Error + 'static + Sync + Send>>

Loading content...

Implementors

impl<'_> Decode<'_, MySql> for BigDecimal

fn decode(
    value: MySqlValueRef<'_>
) -> Result<BigDecimal, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for Decimal

fn decode(
    value: MySqlValueRef<'_>
) -> Result<Decimal, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for Uuid

fn decode(
    value: MySqlValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, MySql> for Hyphenated

fn decode(
    value: MySqlValueRef<'_>
) -> Result<Hyphenated, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for IpNetwork

fn decode(
    value: PgValueRef<'_>
) -> Result<IpNetwork, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for PgMoney

fn decode(
    value: PgValueRef<'_>
) -> Result<PgMoney, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for BigDecimal

fn decode(
    value: PgValueRef<'_>
) -> Result<BigDecimal, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for Decimal

fn decode(
    value: PgValueRef<'_>
) -> Result<Decimal, Box<dyn Error + 'static + Sync + Send>>

impl<'_> Decode<'_, Postgres> for Uuid

fn decode(
    value: PgValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send>>

impl<'de> Decode<'de, Postgres> for PgInterval

fn decode(
    value: PgValueRef<'de>
) -> Result<PgInterval, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for DateTime<Utc>

fn decode(
    value: MySqlValueRef<'r>
) -> Result<DateTime<Utc>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for NaiveDate

fn decode(
    value: MySqlValueRef<'r>
) -> Result<NaiveDate, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for NaiveDateTime

fn decode(
    value: MySqlValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for NaiveTime

fn decode(
    value: MySqlValueRef<'r>
) -> Result<NaiveTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for Date

fn decode(
    value: MySqlValueRef<'r>
) -> Result<Date, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for OffsetDateTime

fn decode(
    value: MySqlValueRef<'r>
) -> Result<OffsetDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for PrimitiveDateTime

fn decode(
    value: MySqlValueRef<'r>
) -> Result<PrimitiveDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, MySql> for Time

fn decode(
    value: MySqlValueRef<'r>
) -> Result<Time, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for PgTimeTz<NaiveTime, FixedOffset>

fn decode(
    value: PgValueRef<'r>
) -> Result<PgTimeTz<NaiveTime, FixedOffset>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for PgTimeTz<Time, UtcOffset>

fn decode(
    value: PgValueRef<'r>
) -> Result<PgTimeTz<Time, UtcOffset>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for DateTime<FixedOffset>

fn decode(
    value: PgValueRef<'r>
) -> Result<DateTime<FixedOffset>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for DateTime<Local>

fn decode(
    value: PgValueRef<'r>
) -> Result<DateTime<Local>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for DateTime<Utc>

fn decode(
    value: PgValueRef<'r>
) -> Result<DateTime<Utc>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for NaiveDate

fn decode(
    value: PgValueRef<'r>
) -> Result<NaiveDate, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for NaiveDateTime

fn decode(
    value: PgValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for NaiveTime

fn decode(
    value: PgValueRef<'r>
) -> Result<NaiveTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for Date

fn decode(
    value: PgValueRef<'r>
) -> Result<Date, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for OffsetDateTime

fn decode(
    value: PgValueRef<'r>
) -> Result<OffsetDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for PrimitiveDateTime

fn decode(
    value: PgValueRef<'r>
) -> Result<PrimitiveDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Postgres> for Time

fn decode(
    value: PgValueRef<'r>
) -> Result<Time, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for DateTime<FixedOffset>

fn decode(
    value: SqliteValueRef<'r>
) -> Result<DateTime<FixedOffset>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for DateTime<Local>

fn decode(
    value: SqliteValueRef<'r>
) -> Result<DateTime<Local>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for DateTime<Utc>

fn decode(
    value: SqliteValueRef<'r>
) -> Result<DateTime<Utc>, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for NaiveDate

fn decode(
    value: SqliteValueRef<'r>
) -> Result<NaiveDate, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for NaiveDateTime

fn decode(
    value: SqliteValueRef<'r>
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r> Decode<'r, Sqlite> for NaiveTime

fn decode(
    value: SqliteValueRef<'r>
) -> Result<NaiveTime, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T> Decode<'r, MySql> for Json<T> where
    T: 'r + Deserialize<'r>, 

fn decode(
    value: MySqlValueRef<'r>
) -> Result<Json<T>, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T> Decode<'r, Postgres> for PgRange<T> where
    T: Type<Postgres> + for<'a> Decode<'a, Postgres>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<PgRange<T>, Box<dyn Error + 'static + Sync + Send>>

impl<'r, T> Decode<'r, Postgres> for Json<T> where
    T: 'r + Deserialize<'r>, 

fn decode(
    value: PgValueRef<'r>
) -> Result<Json<T>, Box<dyn Error + 'static + Sync + Send>>

Loading content...