Trait tokio_postgres::types::FromSql

pub trait FromSql<'a> {
    fn from_sql(
        ty: &Type, 
        raw: &'a [u8]
    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync>>;
    fn accepts(ty: &Type) -> bool;

    fn from_sql_null(
        ty: &Type
    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync>> { ... }
    fn from_sql_nullable(
        ty: &Type, 
        raw: Option<&'a [u8]>
    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync>> { ... }
}

A trait for types that can be created from a Postgres value.

Types

The following implementations are provided by this crate, along with the corresponding Postgres types:

Rust type	Postgres type(s)
bool	BOOL
i8	"char"
i16	SMALLINT, SMALLSERIAL
i32	INT, SERIAL
u32	OID
i64	BIGINT, BIGSERIAL
f32	REAL
f64	DOUBLE PRECISION
&str/String	VARCHAR, CHAR(n), TEXT, CITEXT, NAME, UNKNOWN
&[u8]/Vec<u8>	BYTEA
HashMap<String, Option<String>>	HSTORE
SystemTime	TIMESTAMP, TIMESTAMP WITH TIME ZONE
IpAddr	INET

In addition, some implementations are provided for types in third party crates. These are disabled by default; to opt into one of these implementations, activate the Cargo feature corresponding to the crate's name prefixed by with-. For example, the with-serde_json-1 feature enables the implementation for the serde_json::Value type.

Rust type	Postgres type(s)
chrono::NaiveDateTime	TIMESTAMP
chrono::DateTime<Utc>	TIMESTAMP WITH TIME ZONE
chrono::DateTime<Local>	TIMESTAMP WITH TIME ZONE
chrono::DateTime<FixedOffset>	TIMESTAMP WITH TIME ZONE
chrono::NaiveDate	DATE
chrono::NaiveTime	TIME
time::PrimitiveDateTime	TIMESTAMP
time::OffsetDateTime	TIMESTAMP WITH TIME ZONE
time::Date	DATE
time::Time	TIME
eui48::MacAddress	MACADDR
geo_types::Point<f64>	POINT
geo_types::Rect<f64>	BOX
geo_types::LineString<f64>	PATH
serde_json::Value	JSON, JSONB
uuid::Uuid	UUID
bit_vec::BitVec	BIT, VARBIT
eui48::MacAddress	MACADDR

Nullability

In addition to the types listed above, FromSql is implemented for Option<T> where T implements FromSql. An Option<T> represents a nullable Postgres value.

Arrays

FromSql is implemented for Vec<T> where T implements FromSql, and corresponds to one-dimensional Postgres arrays.

Required methods

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Self, Box<dyn Error + 'static + Send + Sync>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

The caller of this method is responsible for ensuring that this type is compatible with the Postgres Type.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

Loading content...

Provided methods

fn from_sql_null(
    ty: &Type
) -> Result<Self, Box<dyn Error + 'static + Send + Sync>>

Creates a new value of this type from a NULL SQL value.

The caller of this method is responsible for ensuring that this type is compatible with the Postgres Type.

The default implementation returns Err(Box::new(WasNull)).

fn from_sql_nullable(
    ty: &Type,
    raw: Option<&'a [u8]>
) -> Result<Self, Box<dyn Error + 'static + Send + Sync>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

Loading content...

Implementations on Foreign Types

impl<'a> FromSql<'a> for Value

fn from_sql(
    ty: &Type,
    raw: &[u8]
) -> Result<Value, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Uuid

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<Uuid, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a, T> FromSql<'a> for Vec<T> where
    T: FromSql<'a>, 

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Vec<T>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Time

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<Time, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for String

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<String, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for f32

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<f32, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for NaiveDate

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<NaiveDate, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for i16

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<i16, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Vec<u8>

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<Vec<u8>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a, S> FromSql<'a> for HashMap<String, Option<String>, S> where
    S: Default + BuildHasher, 

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<HashMap<String, Option<String>, S>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for LineString<f64>

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<LineString<f64>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for BitVec<u32>

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<BitVec<u32>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Date

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<Date, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Point<f64>

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<Point<f64>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for NaiveDateTime

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<NaiveDateTime, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for NaiveTime

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<NaiveTime, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for i64

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<i64, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for i8

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<i8, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for f64

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<f64, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for &'a str

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<&'a str, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for DateTime<Local>

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

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for bool

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<bool, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for PrimitiveDateTime

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<PrimitiveDateTime, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for MacAddress

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<MacAddress, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for Rect<f64>

fn from_sql(
    &Type,
    raw: &[u8]
) -> Result<Rect<f64>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for DateTime<Utc>

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

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for SystemTime

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<SystemTime, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for IpAddr

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<IpAddr, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for DateTime<FixedOffset>

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

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for &'a [u8]

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<&'a [u8], Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for u32

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<u32, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for OffsetDateTime

fn from_sql(
    type_: &Type,
    raw: &[u8]
) -> Result<OffsetDateTime, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a> FromSql<'a> for i32

fn from_sql(
    &Type,
    raw: &'a [u8]
) -> Result<i32, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a, T> FromSql<'a> for Option<T> where
    T: FromSql<'a>, 

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Option<T>, Box<dyn Error + 'static + Send + Sync>>

fn from_sql_null(
    &Type
) -> Result<Option<T>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

Loading content...

Implementors

impl<'a, T> FromSql<'a> for tokio_postgres::types::Date<T> where
    T: FromSql<'a>, 

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Date<T>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a, T> FromSql<'a> for Timestamp<T> where
    T: FromSql<'a>, 

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Timestamp<T>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

impl<'a, T> FromSql<'a> for Json<T> where
    T: Deserialize<'a>, 

fn from_sql(
    ty: &Type,
    raw: &'a [u8]
) -> Result<Json<T>, Box<dyn Error + 'static + Send + Sync>>

fn accepts(ty: &Type) -> bool

Loading content...