Trait amadeus::prelude::postgres::PostgresData

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

Required methods

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

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

Loading content...

Implementations on Foreign Types

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

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

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

impl PostgresData for Box<[u8; 7]>

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

impl PostgresData for [u8; 9]

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

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

impl PostgresData for [u8; 8]

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

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

impl PostgresData for [u8; 2]

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

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

impl PostgresData for [u8; 6]

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

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

impl PostgresData for [u8; 17]

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

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

impl PostgresData for i8

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

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

impl PostgresData for Box<[u8; 15]>

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

impl PostgresData for [u8; 30]

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

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for f64

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

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

impl PostgresData for [u8; 0]

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

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

impl PostgresData for Box<[u8; 3]>

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

impl PostgresData for Box<[u8; 30]>

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

impl PostgresData for u16

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

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

impl PostgresData for Box<[u8; 25]>

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for [u8; 32]

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

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

impl PostgresData for i64

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

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

impl PostgresData for Box<[u8; 21]>

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

impl PostgresData for [u8; 11]

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

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

impl PostgresData for Box<[u8; 23]>

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

impl PostgresData for [u8; 12]

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

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

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

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

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

impl PostgresData for Box<[u8; 4]>

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

impl PostgresData for Box<[u8; 9]>

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

impl PostgresData for Box<[u8; 31]>

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

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

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

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

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

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

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

impl PostgresData for Box<[u8; 29]>

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G, H, I, J), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for [u8; 3]

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

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

impl PostgresData for Box<[u8; 5]>

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

impl PostgresData for [u8; 23]

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

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

impl PostgresData for [u8; 28]

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

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

impl PostgresData for [u8; 18]

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

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

impl PostgresData for Box<[u8; 10]>

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

impl PostgresData for [u8; 1]

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

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

impl PostgresData for Box<[u8; 6]>

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

impl PostgresData for Box<[u8; 27]>

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

impl PostgresData for Box<[u8; 24]>

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

impl PostgresData for Box<[u8; 14]>

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

impl PostgresData for Box<[u8; 16]>

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

impl PostgresData for Box<[u8; 32]>

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

impl PostgresData for [u8; 29]

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

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

impl PostgresData for i16

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

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

impl PostgresData for u64

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

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

impl PostgresData for Box<[u8; 28]>

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

impl PostgresData for Box<[u8; 20]>

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

impl PostgresData for Vec<u8>

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

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

impl PostgresData for [u8; 26]

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

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

impl PostgresData for Box<[u8; 26]>

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

impl PostgresData for [u8; 14]

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

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

impl PostgresData for [u8; 22]

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

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

impl PostgresData for Box<[u8; 1]>

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for u8

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

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

impl PostgresData for Box<[u8; 22]>

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G, H, I, J, K), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for [u8; 5]

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

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

impl PostgresData for [u8; 31]

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

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for u32

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

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

impl PostgresData for [u8; 25]

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

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

impl PostgresData for Box<[u8; 8]>

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

impl PostgresData for [u8; 20]

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

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

impl PostgresData for [u8; 24]

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

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for Box<[u8; 19]>

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

impl PostgresData for Box<[u8; 11]>

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

impl PostgresData for String

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

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

impl PostgresData for [u8; 16]

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

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

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<(), Error>

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

impl PostgresData for [u8; 4]

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

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

impl PostgresData for Box<[u8; 18]>

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

impl PostgresData for Box<[u8; 17]>

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

impl PostgresData for [u8; 21]

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

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

impl PostgresData for [u8; 27]

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

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

impl PostgresData for [u8; 15]

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

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

impl PostgresData for [u8; 7]

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

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

impl PostgresData for [u8; 10]

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

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

impl PostgresData for Box<[u8; 12]>

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

impl PostgresData for Box<[u8; 13]>

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

impl PostgresData for [u8; 13]

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

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

impl PostgresData for Box<[u8; 2]>

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

impl PostgresData for f32

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

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

impl PostgresData for ()

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

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G, H, I), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for Box<[u8; 0]>

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

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<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<(A, B, C, D, E, F, G, H), Box<dyn Error + 'static + Send + Sync>>

impl PostgresData for bool

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

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

impl PostgresData for i32

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

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

impl PostgresData for [u8; 19]

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

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

Loading content...

Implementors

impl PostgresData for Decimal

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

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

impl PostgresData for IpAddr

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

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

impl PostgresData for Value

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

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

impl PostgresData for Bson

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

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

impl PostgresData for CloudfrontRow

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<(), Error>

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

impl PostgresData for DateTime

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

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

impl PostgresData for DateTimeWithoutTimezone

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

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

impl PostgresData for DateWithoutTimezone

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

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

impl PostgresData for Enum

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

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

impl PostgresData for Group

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

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

impl PostgresData for Json

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

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

impl PostgresData for Time

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

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

impl PostgresData for TimeWithoutTimezone

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

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

impl PostgresData for Timezone

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

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

impl PostgresData for Url

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

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

impl PostgresData for Webpage<'static>

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

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

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

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

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

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

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

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

Loading content...