Trait diesel::types::ToSql

pub trait ToSql<A, DB: Backend + HasSqlType<A>>: Debug {
    fn to_sql<W: Write>(
        &self, 
        out: &mut ToSqlOutput<W, DB>
    ) -> Result<IsNull, Box<Error + Send + Sync>>;
}

Serializes a single value to be sent to the database.

The output is sent as a bind parameter, and the data must be written in the expected format for the given backend.

When possible, implementations of this trait should prefer using an existing implementation, rather than writing to out directly. (For example, if you are implementing this for an enum, which is represented as an integer in the database, you should use i32::to_sql(x, out) instead of writing to out yourself.

Backend specific details

• For PostgreSQL, the bytes will be sent using the binary protocol, not text.
• For SQLite, all implementations should be written in terms of an existing ToSql implementation.
• For MySQL, the expected bytes will depend on the return value of type_metadata for the given SQL type. See MysqlType for details.
• For third party backends, consult that backend's documentation.

Required Methods

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

See the trait documentation.

Implementations on Foreign Types

impl<DB> ToSql<Nullable<Date>, DB> for NaiveDate where
    DB: Backend + HasSqlType<Date>,
    NaiveDate: ToSql<Date, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Time>, DB> for NaiveTime where
    DB: Backend + HasSqlType<Time>,
    NaiveTime: ToSql<Time, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamp>, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamp>,
    NaiveDateTime: ToSql<Timestamp, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<Float, DB> for f32

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<Double, DB> for f64

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<SmallInt, DB> for i16

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<Integer, DB> for i32

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<BigInt, DB> for i64

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<T, ST, DB> ToSql<Nullable<ST>, DB> for Option<T> where
    T: ToSql<ST, DB>,
    DB: Backend + HasSqlType<ST>,
    ST: NotNull, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Bool>, DB> for bool where
    DB: Backend + HasSqlType<Bool>,
    bool: ToSql<Bool, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<SmallInt>, DB> for i16 where
    DB: Backend + HasSqlType<SmallInt>,
    i16: ToSql<SmallInt, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Integer>, DB> for i32 where
    DB: Backend + HasSqlType<Integer>,
    i32: ToSql<Integer, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<BigInt>, DB> for i64 where
    DB: Backend + HasSqlType<BigInt>,
    i64: ToSql<BigInt, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Float>, DB> for f32 where
    DB: Backend + HasSqlType<Float>,
    f32: ToSql<Float, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Double>, DB> for f64 where
    DB: Backend + HasSqlType<Double>,
    f64: ToSql<Double, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Text>, DB> for String where
    DB: Backend + HasSqlType<Text>,
    String: ToSql<Text, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Binary>, DB> for Vec<u8> where
    DB: Backend + HasSqlType<Binary>,
    Vec<u8>: ToSql<Binary, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Text>, DB> for str where
    DB: Backend + HasSqlType<Text>,
    str: ToSql<Text, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Binary>, DB> for [u8] where
    DB: Backend + HasSqlType<Binary>,
    [u8]: ToSql<Binary, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<Text, DB> for str

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Text, DB> for String where
    DB: Backend,
    str: ToSql<Text, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Binary, DB> for Vec<u8> where
    DB: Backend,
    [u8]: ToSql<Binary, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB: Backend> ToSql<Binary, DB> for [u8]

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<'a, T: ?Sized, ST, DB> ToSql<ST, DB> for Cow<'a, T> where
    T: 'a + ToOwned + ToSql<ST, DB>,
    DB: Backend + HasSqlType<ST>,
    T::Owned: ToSql<ST, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Numeric>, DB> for BigDecimal where
    DB: Backend + HasSqlType<Numeric>,
    BigDecimal: ToSql<Numeric, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<'a, A, T: ?Sized, DB> ToSql<A, DB> for &'a T where
    DB: Backend + HasSqlType<A>,
    T: ToSql<A, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Datetime, Mysql> for MYSQL_TIME

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Datetime>, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Datetime>,
    NaiveDateTime: ToSql<Datetime, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Mysql> for MYSQL_TIME

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Mysql> for MYSQL_TIME

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Mysql> for MYSQL_TIME

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Datetime, Mysql> for NaiveDateTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Mysql> for NaiveDateTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Mysql> for NaiveTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Mysql> for NaiveDate

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Numeric, Mysql> for BigDecimal

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Tinyint>, DB> for i8 where
    DB: Backend + HasSqlType<Tinyint>,
    i8: ToSql<Tinyint, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Tinyint, Mysql> for i8

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<StdError + Send + Sync>>

impl ToSql<Bool, Mysql> for bool

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Mysql>
) -> Result<IsNull, Box<StdError + Send + Sync>>

impl<ST, T> ToSql<Array<ST>, Pg> for [T] where
    Pg: HasSqlType<ST>,
    T: ToSql<ST, Pg>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for [T] where
    Pg: HasSqlType<ST>,
    [T]: ToSql<Array<ST>, Pg>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<ST, T> ToSql<Array<ST>, Pg> for Vec<T> where
    Pg: HasSqlType<ST>,
    [T]: ToSql<Array<ST>, Pg>,
    T: Debug, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for Vec<T> where
    Pg: HasSqlType<ST>,
    Vec<T>: ToSql<Array<ST>, Pg>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<ST, T> ToSql<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>,
    T: ToSql<ST, Pg>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<ST, T> ToSql<Nullable<Range<ST>>, Pg> for (Bound<T>, Bound<T>) where
    Pg: HasSqlType<Range<ST>>,
    (Bound<T>, Bound<T>): ToSql<Range<ST>, Pg>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamp>, DB> for SystemTime where
    DB: Backend + HasSqlType<Timestamp>,
    SystemTime: ToSql<Timestamp, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Pg> for SystemTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamptz>, DB> for NaiveDateTime where
    DB: Backend + HasSqlType<Timestamptz>,
    NaiveDateTime: ToSql<Timestamptz, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamptz>, DB> for DateTime<Utc> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<Utc>: ToSql<Timestamptz, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamptz>, DB> for DateTime<FixedOffset> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<FixedOffset>: ToSql<Timestamptz, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamptz>, DB> for DateTime<Local> where
    DB: Backend + HasSqlType<Timestamptz>,
    DateTime<Local>: ToSql<Timestamptz, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Pg> for NaiveDateTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamptz, Pg> for NaiveDateTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<TZ: TimeZone> ToSql<Timestamptz, Pg> for DateTime<TZ>

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Pg> for NaiveTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Pg> for NaiveDate

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamp>, DB> for Timespec where
    DB: Backend + HasSqlType<Timestamp>,
    Timespec: ToSql<Timestamp, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Pg> for Timespec

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<MacAddr>, DB> for [u8; 6] where
    DB: Backend + HasSqlType<MacAddr>,
    [u8; 6]: ToSql<MacAddr, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Inet>, DB> for IpNetwork where
    DB: Backend + HasSqlType<Inet>,
    IpNetwork: ToSql<Inet, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Cidr>, DB> for IpNetwork where
    DB: Backend + HasSqlType<Cidr>,
    IpNetwork: ToSql<Cidr, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<MacAddr, Pg> for [u8; 6]

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Inet, Pg> for IpNetwork

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Cidr, Pg> for IpNetwork

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Oid>, DB> for u32 where
    DB: Backend + HasSqlType<Oid>,
    u32: ToSql<Oid, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Oid, Pg> for u32

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Numeric, Pg> for BigDecimal

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Bool, Pg> for bool

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Uuid>, DB> for Uuid where
    DB: Backend + HasSqlType<Uuid>,
    Uuid: ToSql<Uuid, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Uuid, Pg> for Uuid

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Json>, DB> for Value where
    DB: Backend + HasSqlType<Json>,
    Value: ToSql<Json, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Jsonb>, DB> for Value where
    DB: Backend + HasSqlType<Jsonb>,
    Value: ToSql<Jsonb, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Json, Pg> for Value

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Jsonb, Pg> for Value

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Pg>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Sqlite> for NaiveDate

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Sqlite> for NaiveTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Sqlite> for NaiveDateTime

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Date>, DB> for String where
    DB: Backend + HasSqlType<Date>,
    String: ToSql<Date, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Date>, DB> for str where
    DB: Backend + HasSqlType<Date>,
    str: ToSql<Date, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Time>, DB> for String where
    DB: Backend + HasSqlType<Time>,
    String: ToSql<Time, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Time>, DB> for str where
    DB: Backend + HasSqlType<Time>,
    str: ToSql<Time, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamp>, DB> for String where
    DB: Backend + HasSqlType<Timestamp>,
    String: ToSql<Timestamp, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl<DB> ToSql<Nullable<Timestamp>, DB> for str where
    DB: Backend + HasSqlType<Timestamp>,
    str: ToSql<Timestamp, DB>, 

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, DB>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Sqlite> for str

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Date, Sqlite> for String

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Sqlite> for str

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Time, Sqlite> for String

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Sqlite> for str

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Timestamp, Sqlite> for String

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

impl ToSql<Bool, Sqlite> for bool

fn to_sql<W: Write>(
    &self,
    out: &mut ToSqlOutput<W, Sqlite>
) -> Result<IsNull, Box<Error + Send + Sync>>

Implementors

• impl<DB> ToSql<Nullable<Date>, DB> for PgDate where
    DB: Backend + HasSqlType<Date>,
    PgDate: ToSql<Date, DB>, 
• impl<DB> ToSql<Nullable<Time>, DB> for PgTime where
    DB: Backend + HasSqlType<Time>,
    PgTime: ToSql<Time, DB>, 
• impl<DB> ToSql<Nullable<Timestamp>, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamp>,
    PgTimestamp: ToSql<Timestamp, DB>, 
• impl<DB> ToSql<Nullable<Timestamptz>, DB> for PgTimestamp where
    DB: Backend + HasSqlType<Timestamptz>,
    PgTimestamp: ToSql<Timestamptz, DB>, 
• impl<DB> ToSql<Nullable<Interval>, DB> for PgInterval where
    DB: Backend + HasSqlType<Interval>,
    PgInterval: ToSql<Interval, DB>, 
• impl ToSql<Timestamp, Pg> for PgTimestamp
• impl ToSql<Timestamptz, Pg> for PgTimestamp
• impl ToSql<Date, Pg> for PgDate
• impl ToSql<Time, Pg> for PgTime
• impl ToSql<Interval, Pg> for PgInterval
• impl ToSql<Numeric, Pg> for PgNumeric
• impl<DB> ToSql<Nullable<Numeric>, DB> for PgNumeric where
    DB: Backend + HasSqlType<Numeric>,
    PgNumeric: ToSql<Numeric, DB>, 
• impl<DB> ToSql<Nullable<Money>, DB> for PgMoney where
    DB: Backend + HasSqlType<Money>,
    PgMoney: ToSql<Money, DB>, 
• impl ToSql<Money, Pg> for PgMoney