Trait postgres::types::FromSql

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

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

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

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

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.

pub fn accepts(ty: &Type) -> bool

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

Loading content...

Provided methods

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

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)).

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

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 OffsetDateTime

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

Loading content...

Implementors

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

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

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

pub fn accepts(ty: &Type) -> bool

Loading content...