Trait sqlx::Decode

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

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

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

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

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'r, DB> Decode<'r, DB> for BString where
    DB: Database,
    Vec<u8, Global>: Decode<'r, DB>, 

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

impl<'r, DB> Decode<'r, DB> for Oid where
    DB: Database,
    &'r [u8]: Decode<'r, DB>, 

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

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

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

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

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

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

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

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

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

Loading content...