Add type aliases for the return types of ToSql and FromSql

These types were annoying to write out, and often involved importing
several types you wouldn't otherwise need to import.

These aliases are `serialize::Result` and `deserialize::Result`. I
intend to eventually move the relevant traits into these modules, but
this felt like a good standalone change.

Author: sgrif

CHANGELOG.md

@@ -19,6 +19,11 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * `HasSqlType`, `NotNull`, and `SingleValue` can now be derived with
   `#[derive(SqlType)]`. See the docs for those traits for more information.
 
+* The return type of `FromSql`, `FromSqlRow`, and `QueryableByName` can now be
+  written as `deserialize::Result<Self>`.
+
+* The return type of `ToSql` can now be written as `serialize::Result`.
+
 ### Deprecated
 
 * Deprecated `impl_query_id!` in favor of `#[derive(QueryId)]`

diesel/src/deserialize.rs

@@ -0,0 +1,8 @@
+//! Types and traits related to deserializing values from the database
+
+use std::error::Error;
+use std::result;
+
+/// A specialized result type representing the result of deserializing
+/// a value from the database.
+pub type Result<T> = result::Result<T, Box<Error + Send + Sync>>;

diesel/src/lib.rs

@@ -136,12 +136,14 @@ pub mod associations;
 pub mod backend;
 #[doc(hidden)]
 pub mod connection;
+pub mod deserialize;
 #[macro_use]
 pub mod expression;
 pub mod expression_methods;
 #[doc(hidden)]
 pub mod insertable;
 pub mod query_builder;
+pub mod serialize;
 #[macro_use]
 pub mod types;
 

diesel/src/mysql/types/date_and_time.rs

@@ -2,18 +2,18 @@ extern crate chrono;
 extern crate mysqlclient_sys as ffi;
 
 use self::chrono::*;
-use std::error::Error;
 use std::io::Write;
 use std::os::raw as libc;
 use std::{mem, ptr, slice};
 
 use mysql::Mysql;
 use types::{Date, Datetime, FromSql, IsNull, Time, Timestamp, ToSql, ToSqlOutput};
+use {deserialize, serialize};
 
 macro_rules! mysql_time_impls {
     ($ty:ty) => {
         impl ToSql<$ty, Mysql> for ffi::MYSQL_TIME {
-            fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> Result<IsNull, Box<Error+Send+Sync>> {
+            fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
                 let bytes = unsafe {
                     let bytes_ptr = self as *const ffi::MYSQL_TIME as *const u8;
                     slice::from_raw_parts(bytes_ptr, mem::size_of::<ffi::MYSQL_TIME>())
@@ -24,7 +24,7 @@ macro_rules! mysql_time_impls {
         }
 
         impl FromSql<$ty, Mysql> for ffi::MYSQL_TIME {
-            fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error+Send+Sync>> {
+            fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
                 let bytes = not_none!(bytes);
                 let bytes_ptr = bytes.as_ptr() as *const ffi::MYSQL_TIME;
                 unsafe {
@@ -47,25 +47,19 @@ mysql_time_impls!(Time);
 mysql_time_impls!(Date);
 
 impl ToSql<Datetime, Mysql> for NaiveDateTime {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
         <NaiveDateTime as ToSql<Timestamp, Mysql>>::to_sql(self, out)
     }
 }
 
 impl FromSql<Datetime, Mysql> for NaiveDateTime {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         <NaiveDateTime as FromSql<Timestamp, Mysql>>::from_sql(bytes)
     }
 }
 
 impl ToSql<Timestamp, Mysql> for NaiveDateTime {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
         let mut mysql_time: ffi::MYSQL_TIME = unsafe { mem::zeroed() };
 
         mysql_time.year = self.year() as libc::c_uint;
@@ -81,7 +75,7 @@ impl ToSql<Timestamp, Mysql> for NaiveDateTime {
 }
 
 impl FromSql<Timestamp, Mysql> for NaiveDateTime {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         let mysql_time = <ffi::MYSQL_TIME as FromSql<Timestamp, Mysql>>::from_sql(bytes)?;
 
         NaiveDate::from_ymd_opt(
@@ -101,10 +95,7 @@ impl FromSql<Timestamp, Mysql> for NaiveDateTime {
 }
 
 impl ToSql<Time, Mysql> for NaiveTime {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
         let mut mysql_time: ffi::MYSQL_TIME = unsafe { mem::zeroed() };
 
         mysql_time.hour = self.hour() as libc::c_uint;
@@ -116,7 +107,7 @@ impl ToSql<Time, Mysql> for NaiveTime {
 }
 
 impl FromSql<Time, Mysql> for NaiveTime {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         let mysql_time = <ffi::MYSQL_TIME as FromSql<Time, Mysql>>::from_sql(bytes)?;
         NaiveTime::from_hms_opt(
             mysql_time.hour as u32,
@@ -127,10 +118,7 @@ impl FromSql<Time, Mysql> for NaiveTime {
 }
 
 impl ToSql<Date, Mysql> for NaiveDate {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
         let mut mysql_time: ffi::MYSQL_TIME = unsafe { mem::zeroed() };
 
         mysql_time.year = self.year() as libc::c_uint;
@@ -142,7 +130,7 @@ impl ToSql<Date, Mysql> for NaiveDate {
 }
 
 impl FromSql<Date, Mysql> for NaiveDate {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         let mysql_time = <ffi::MYSQL_TIME as FromSql<Date, Mysql>>::from_sql(bytes)?;
         NaiveDate::from_ymd_opt(
             mysql_time.year as i32,

diesel/src/mysql/types/mod.rs

@@ -6,40 +6,32 @@ mod numeric;
 
 use byteorder::WriteBytesExt;
 use mysql::Mysql;
-use std::error::Error as StdError;
 use std::io::Write;
 use types::{self, FromSql, IsNull, ToSql, ToSqlOutput};
+use {deserialize, serialize};
 
 impl ToSql<types::Tinyint, Mysql> for i8 {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<StdError + Send + Sync>> {
-        out.write_i8(*self)
-            .map(|_| IsNull::No)
-            .map_err(|e| Box::new(e) as Box<StdError + Send + Sync>)
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
+        out.write_i8(*self).map(|_| IsNull::No).map_err(Into::into)
     }
 }
 
 impl FromSql<types::Tinyint, Mysql> for i8 {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<StdError + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         let bytes = not_none!(bytes);
         Ok(bytes[0] as i8)
     }
 }
 
 impl ToSql<types::Bool, Mysql> for bool {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Mysql>,
-    ) -> Result<IsNull, Box<StdError + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
         let int_value = if *self { 1 } else { 0 };
         <i32 as ToSql<types::Integer, Mysql>>::to_sql(&int_value, out)
     }
 }
 
 impl FromSql<types::Bool, Mysql> for bool {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<StdError + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         Ok(not_none!(bytes).iter().any(|x| *x != 0))
     }
 }

diesel/src/mysql/types/numeric.rs

@@ -2,28 +2,23 @@
 pub mod bigdecimal {
     extern crate bigdecimal;
 
-    use std::error::Error;
+    use self::bigdecimal::BigDecimal;
     use std::io::prelude::*;
 
     use mysql::Mysql;
-
-    use self::bigdecimal::BigDecimal;
-
     use types::{self, FromSql, IsNull, ToSql, ToSqlOutput};
+    use {deserialize, serialize};
 
     impl ToSql<types::Numeric, Mysql> for BigDecimal {
-        fn to_sql<W: Write>(
-            &self,
-            out: &mut ToSqlOutput<W, Mysql>,
-        ) -> Result<IsNull, Box<Error + Send + Sync>> {
+        fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Mysql>) -> serialize::Result {
             write!(out, "{}", *self)
                 .map(|_| IsNull::No)
                 .map_err(|e| e.into())
         }
     }
 
     impl FromSql<types::Numeric, Mysql> for BigDecimal {
-        fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+        fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
             let bytes = not_none!(bytes);
             BigDecimal::parse_bytes(bytes, 10)
                 .ok_or_else(|| Box::from(format!("{:?} is not valid decimal number ", bytes)))

diesel/src/pg/types/array.rs

@@ -1,10 +1,10 @@
 use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt};
-use std::error::Error;
 use std::fmt;
 use std::io::Write;
 
 use pg::{Pg, PgMetadataLookup, PgTypeMetadata};
 use types::*;
+use {deserialize, serialize};
 
 impl<T> HasSqlType<Array<T>> for Pg
 where
@@ -26,7 +26,7 @@ impl<T, ST> FromSql<Array<ST>, Pg> for Vec<T>
 where
     T: FromSql<ST, Pg>,
 {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
         let mut bytes = not_none!(bytes);
         let num_dimensions = try!(bytes.read_i32::<NetworkEndian>());
         let has_null = try!(bytes.read_i32::<NetworkEndian>()) != 0;
@@ -92,10 +92,7 @@ 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>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Pg>) -> serialize::Result {
         let num_dimensions = 1;
         try!(out.write_i32::<NetworkEndian>(num_dimensions));
         let flags = 0;
@@ -127,10 +124,7 @@ impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for [T]
 where
     [T]: ToSql<Array<ST>, Pg>,
 {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Pg>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Pg>) -> serialize::Result {
         ToSql::<Array<ST>, Pg>::to_sql(self, out)
     }
 }
@@ -140,10 +134,7 @@ where
     [T]: ToSql<Array<ST>, Pg>,
     T: fmt::Debug,
 {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Pg>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Pg>) -> serialize::Result {
         (self as &[T]).to_sql(out)
     }
 }
@@ -152,10 +143,7 @@ impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for Vec<T>
 where
     Vec<T>: ToSql<Array<ST>, Pg>,
 {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut ToSqlOutput<W, Pg>,
-    ) -> Result<IsNull, Box<Error + Send + Sync>> {
+    fn to_sql<W: Write>(&self, out: &mut ToSqlOutput<W, Pg>) -> serialize::Result {
         ToSql::<Array<ST>, Pg>::to_sql(self, out)
     }
 }