Trait sqlx::Decode

pub trait Decode<'r, DB>: Sizedwhere
    DB: Database,{
    // Required method
    fn decode(
        value: <DB as HasValueRef<'r>>::ValueRef
    ) -> Result<Self, Box<dyn Error + Sync + Send + 'static, 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

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

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

Implementations on Foreign Types

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

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

impl Decode<'_, MySql> for bool

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

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

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

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

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

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

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

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

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

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

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

impl Decode<'_, Mssql> for bool

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

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

impl Decode<'_, MySql> for u32

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

impl Decode<'_, MySql> for i8

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

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

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

impl Decode<'_, MySql> for i32

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

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

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

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

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

impl Decode<'_, Postgres> for f32

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

impl Decode<'_, Mssql> for u8

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

impl Decode<'_, MySql> for u16

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

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

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

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

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

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

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

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

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

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

impl Decode<'_, Mssql> for String

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

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

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

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

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

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

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

impl Decode<'_, MySql> for f64

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

impl Decode<'_, MySql> for u8

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

impl Decode<'_, Postgres> for bool

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

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

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

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

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

impl Decode<'_, Postgres> for f64

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

impl Decode<'_, Postgres> for i32

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

impl<'r, T, const N: usize> Decode<'r, Postgres> for [T; N]where T: for<'a> Decode<'a, Postgres> + Type<Postgres>,

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

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

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

impl<const N: usize> Decode<'_, Postgres> for [u8; N]

fn decode( value: PgValueRef<'_> ) -> Result<[u8; N], Box<dyn Error + Sync + Send + 'static, 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>,

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

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

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

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

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

impl Decode<'_, Postgres> for i8

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

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

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

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

impl<'r> Decode<'r, Any> for i16where i16: AnyDecode<'r>,

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

impl Decode<'_, MySql> for i64

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

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

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

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

impl<'db> Decode<'db, Postgres> for IpAddrwhere IpNetwork: Decode<'db, Postgres>,

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

impl Decode<'_, Mssql> for i16

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

impl Decode<'_, Postgres> for String

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

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

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

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

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

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

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

impl Decode<'_, Mssql> for i64

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

impl Decode<'_, MySql> for f32

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

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 + Sync + Send + 'static, Global>>

impl Decode<'_, Postgres> for i16

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

impl Decode<'_, Mssql> for f32

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

impl Decode<'_, Mssql> for i32

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

impl Decode<'_, MySql> for i16

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

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 + Sync + Send + 'static, 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>,

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

impl Decode<'_, Mssql> for f64

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

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

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

impl Decode<'_, MySql> for u64

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

impl Decode<'_, Mssql> for i8

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

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

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

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

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

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

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

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

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

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

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

impl Decode<'_, Postgres> for i64

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

impl<'r> Decode<'r, Mssql> for Cow<'r, str>

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

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

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

impl Decode<'_, MySql> for String

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

Implementors

impl Decode<'_, MySql> for BigDecimal

impl Decode<'_, MySql> for Decimal

impl Decode<'_, MySql> for Uuid

impl Decode<'_, MySql> for Hyphenated

impl Decode<'_, Postgres> for IpNetwork

impl Decode<'_, Postgres> for sqlx::postgres::types::Oid

impl Decode<'_, Postgres> for PgMoney

impl Decode<'_, Postgres> for MacAddress

impl Decode<'_, Postgres> for BigDecimal

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

impl Decode<'_, Postgres> for Decimal

impl Decode<'_, Postgres> for Uuid

impl Decode<'_, Sqlite> for Uuid

impl Decode<'_, Sqlite> for Hyphenated

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

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

Note: assumes the connection’s time_zone is set to +00:00 (UTC).

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

Note: assumes the connection’s time_zone is set to +00:00 (UTC).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'r, DB> Decode<'r, DB> for sqlx::types::git2::Oidwhere DB: Database, &'r [u8]: Decode<'r, DB>,

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

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

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

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