Trait amadeus_postgres::PostgresData

pub trait PostgresData where
    Self: Clone + PartialEq + Debug + 'static, {
    fn query(f: &mut Formatter, name: Option<&Names>) -> Result;
    fn decode(
        type_: &Type, 
        buf: Option<&[u8]>
    ) -> Result<Self, Box<dyn Error + Sync + Send>>;
}

Required methods

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

Loading content...

Implementations on Foreign Types

impl PostgresData for Vec<u8>

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Bson

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Json

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Enum

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 0]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 0]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 1]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 1]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 2]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 2]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 3]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 3]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 4]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 4]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 5]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 5]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 6]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 6]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 7]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 7]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 8]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 8]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 9]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 9]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 10]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 10]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 11]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 11]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 12]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 12]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 13]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 13]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 14]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 14]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 15]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 15]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 16]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 16]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 17]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 17]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 18]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 18]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 19]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 19]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 20]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 20]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 21]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 21]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 22]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 22]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 23]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 23]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 24]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 24]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 25]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 25]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 26]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 26]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 27]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 27]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 28]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 28]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 29]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 29]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 30]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 30]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 31]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 31]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for [u8; 32]

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Box<[u8; 32]>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for ()

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A> PostgresData for (A,) where
    A: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B> PostgresData for (A, B) where
    A: PostgresData,
    B: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C> PostgresData for (A, B, C) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D> PostgresData for (A, B, C, D) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E> PostgresData for (A, B, C, D, E) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F> PostgresData for (A, B, C, D, E, F) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G> PostgresData for (A, B, C, D, E, F, G) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G, H> PostgresData for (A, B, C, D, E, F, G, H) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData,
    H: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G, H, I> PostgresData for (A, B, C, D, E, F, G, H, I) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData,
    H: PostgresData,
    I: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G, H, I, J> PostgresData for (A, B, C, D, E, F, G, H, I, J) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData,
    H: PostgresData,
    I: PostgresData,
    J: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G, H, I, J, K> PostgresData for (A, B, C, D, E, F, G, H, I, J, K) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData,
    H: PostgresData,
    I: PostgresData,
    J: PostgresData,
    K: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<A, B, C, D, E, F, G, H, I, J, K, L> PostgresData for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: PostgresData,
    B: PostgresData,
    C: PostgresData,
    D: PostgresData,
    E: PostgresData,
    F: PostgresData,
    G: PostgresData,
    H: PostgresData,
    I: PostgresData,
    J: PostgresData,
    K: PostgresData,
    L: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Decimal

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Group

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<T> PostgresData for List<T> where
    T: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<K, V> PostgresData for Map<K, V> where
    K: Hash + Eq + PostgresData,
    V: PostgresData, 

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Date

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Time

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Timestamp

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for Value

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for bool

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for u8

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for i8

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for u16

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for i16

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for u32

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for i32

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for u64

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for i64

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for f32

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for f64

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl PostgresData for String

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<T> PostgresData for Option<T> where
    T: PostgresData, 

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

impl<T> PostgresData for Box<T> where
    T: PostgresData, 

fn query(f: &mut Formatter, name: Option<&Names>) -> Result

default fn decode(
    type_: &Type,
    buf: Option<&[u8]>
) -> Result<Self, Box<dyn Error + Sync + Send>>

Loading content...

Implementors

Loading content...