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<T> PostgresData for Box<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 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 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 Url

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 Webpage<'static>

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 IpAddr

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: Data> 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, S> PostgresData for HashMap<K, V, S> where
    K: Hash + Eq + PostgresData,
    V: PostgresData,
    S: BuildHasher + Clone + 'static, 

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 DateWithoutTimezone

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 TimeWithoutTimezone

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 DateTime

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 DateTimeWithoutTimezone

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 Timezone

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<T> PostgresData for [T; 0] 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 [T; 1] 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 [T; 2] 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 [T; 3] 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 [T; 4] 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 [T; 5] 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 [T; 6] 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 [T; 7] 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 [T; 8] 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 [T; 9] 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 [T; 10] 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 [T; 11] 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 [T; 12] 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 [T; 13] 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 [T; 14] 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 [T; 15] 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 [T; 16] 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 [T; 17] 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 [T; 18] 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 [T; 19] 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 [T; 20] 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 [T; 21] 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 [T; 22] 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 [T; 23] 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 [T; 24] 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 [T; 25] 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 [T; 26] 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 [T; 27] 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 [T; 28] 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 [T; 29] 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 [T; 30] 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 [T; 31] 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 [T; 32] 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 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>>

Loading content...

Implementors

Loading content...