Trait sqlx::Decode[−][src]

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

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

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

Implementations on Foreign Types

impl<'r> Decode<'r, Sqlite> for i64[src]

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

impl<'r> Decode<'r, Sqlite> for i16[src]

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

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

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

impl<'_> Decode<'_, MySql> for f64[src]

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

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

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

impl<'r, DB> Decode<'r, DB> for &'r RawValue where
    DB: Database,
    Json<&'r RawValue>: Decode<'r, DB>, [src]

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

impl<'_> Decode<'_, Postgres> for i8[src]

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

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

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

impl<'r> Decode<'r, Sqlite> for String[src]

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

impl<'_> Decode<'_, MySql> for u64[src]

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

impl<'_> Decode<'_, MySql> for bool[src]

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

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

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

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

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

impl<'_> Decode<'_, Postgres> for bool[src]

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

impl<'_> Decode<'_, Mssql> for bool[src]

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

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

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

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

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

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

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

impl<'_> Decode<'_, Postgres> for f32[src]

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

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

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

impl<'r> Decode<'r, Sqlite> for u16[src]

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

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

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

impl<'_> Decode<'_, Postgres> for i16[src]

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

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

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

impl<'r> Decode<'r, Sqlite> for f64[src]

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

impl<'_> Decode<'_, MySql> for i16[src]

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

impl<'r> Decode<'r, Sqlite> for f32[src]

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

impl<'r> Decode<'r, Postgres> for ()[src]

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

impl<'_> Decode<'_, Mssql> for i32[src]

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

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

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

impl<'_> Decode<'_, Mssql> for i8[src]

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

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

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

impl<'_> Decode<'_, Postgres> for String[src]

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

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

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

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

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

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

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

impl<'_> Decode<'_, Postgres> for f64[src]

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

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

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

impl<'_> Decode<'_, Mssql> for f32[src]

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

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

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

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

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

impl<'_> Decode<'_, Mssql> for i16[src]

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

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

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

impl<'_> Decode<'_, MySql> for u16[src]

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

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

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

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

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

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

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

impl<'r, DB> Decode<'r, DB> for Value where
    DB: Database,
    Json<Value>: Decode<'r, DB>, [src]

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

impl<'_> Decode<'_, MySql> for u8[src]

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

impl<'_> Decode<'_, Mssql> for i64[src]

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

impl<'_> Decode<'_, Postgres> for i32[src]

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

impl<'_> Decode<'_, MySql> for i32[src]

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

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

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

impl<'r> Decode<'r, Sqlite> for i32[src]

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

impl<'_> Decode<'_, MySql> for String[src]

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

impl<'r> Decode<'r, Sqlite> for u32[src]

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

impl<'_> Decode<'_, Mssql> for String[src]

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

impl<'_> Decode<'_, Mssql> for f64[src]

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

impl<'_> Decode<'_, MySql> for i64[src]

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

impl<'r> Decode<'r, Sqlite> for i8[src]

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

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

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

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

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

impl<'_> Decode<'_, MySql> for f32[src]

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

impl<'_> Decode<'_, MySql> for u32[src]

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

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

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

impl<'_> Decode<'_, MySql> for i8[src]

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

impl<'r> Decode<'r, Sqlite> for bool[src]

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

impl<'_> Decode<'_, Postgres> for u32[src]

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

impl<'_> Decode<'_, Postgres> for i64[src]

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

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

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

Implementors

impl<'_> Decode<'_, MySql> for BigDecimal[src]

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

impl<'_> Decode<'_, MySql> for Decimal[src]

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

impl<'_> Decode<'_, MySql> for Uuid[src]

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

impl<'_> Decode<'_, MySql> for Hyphenated[src]

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

impl<'_> Decode<'_, Postgres> for IpNetwork[src]

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

impl<'_> Decode<'_, Postgres> for PgMoney[src]

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

impl<'_> Decode<'_, Postgres> for BigDecimal[src]

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

impl<'_> Decode<'_, Postgres> for BitVec<u32>[src]

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

impl<'_> Decode<'_, Postgres> for Decimal[src]

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

impl<'_> Decode<'_, Postgres> for Uuid[src]

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

impl<'_> Decode<'_, Sqlite> for Uuid[src]

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

impl<'_> Decode<'_, Sqlite> for Hyphenated[src]

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

impl<'de> Decode<'de, Postgres> for PgInterval[src]

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

impl<'r> Decode<'r, MySql> for DateTime<Utc>[src]

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

impl<'r> Decode<'r, MySql> for NaiveDate[src]

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

impl<'r> Decode<'r, MySql> for NaiveDateTime[src]

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

impl<'r> Decode<'r, MySql> for NaiveTime[src]

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

impl<'r> Decode<'r, MySql> for Date[src]

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

impl<'r> Decode<'r, MySql> for OffsetDateTime[src]

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

impl<'r> Decode<'r, MySql> for PrimitiveDateTime[src]

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

impl<'r> Decode<'r, MySql> for Time[src]

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

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

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

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

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

impl<'r> Decode<'r, Postgres> for DateTime<FixedOffset>[src]

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

impl<'r> Decode<'r, Postgres> for DateTime<Local>[src]

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

impl<'r> Decode<'r, Postgres> for DateTime<Utc>[src]

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

impl<'r> Decode<'r, Postgres> for NaiveDate[src]

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

impl<'r> Decode<'r, Postgres> for NaiveDateTime[src]

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

impl<'r> Decode<'r, Postgres> for NaiveTime[src]

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

impl<'r> Decode<'r, Postgres> for Date[src]

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

impl<'r> Decode<'r, Postgres> for OffsetDateTime[src]

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

impl<'r> Decode<'r, Postgres> for PrimitiveDateTime[src]

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

impl<'r> Decode<'r, Postgres> for Time[src]

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

impl<'r> Decode<'r, Sqlite> for DateTime<FixedOffset>[src]

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

impl<'r> Decode<'r, Sqlite> for DateTime<Local>[src]

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

impl<'r> Decode<'r, Sqlite> for DateTime<Utc>[src]

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

impl<'r> Decode<'r, Sqlite> for NaiveDate[src]

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

impl<'r> Decode<'r, Sqlite> for NaiveDateTime[src]

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

impl<'r> Decode<'r, Sqlite> for NaiveTime[src]

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

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

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

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

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

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

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

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

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

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

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

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

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