Make FromSql and FromSqlRow more generic over the backend

This allows each backend to provide a "value" type that is used by
`FromSql`. This is required for Sqlite support. While I can do some
semi-hacky nonsense to make Sqlite work with our current `ToSql`
structure, there's just no way I can make it work with our `FromSql`
structure.

Sqlite only returns c ints from its values, and there's no way I can
know at the row level the number of bytes that are needed for `FromSql`
for that specific sized integer.

This unfortunately means that we can no longer assume that all backends
provide `String: FromSql<VarChar, Self>`. We can bring this requirement
back by changing `String: FromSql<VarChar, Pg>` to something like `Pg:
CanDeserialize<VarChar, String>`. I'm unsure how this will interact with
coherence, and feels significanly less natural than the `NativeSqlType`
change that we made for this.

I will likely make a similar change for `ToSql` in the future to make
Sqlite work in a less hacky manner.

Author: sgrif

diesel/src/backend.rs

@@ -19,6 +19,7 @@ pub trait Backend where
     Self: HasSqlType<types::Timestamp>,
 {
     type QueryBuilder: QueryBuilder<Self>;
+    type RawValue: ?Sized;
 }
 
 pub trait TypeMetadata {
@@ -29,6 +30,7 @@ pub struct Debug;
 
 impl Backend for Debug {
     type QueryBuilder = DebugQueryBuilder;
+    type RawValue = ();
 }
 
 impl TypeMetadata for Debug {
@@ -45,6 +47,7 @@ pub struct PgTypeMetadata {
 
 impl Backend for Pg {
     type QueryBuilder = PgQueryBuilder;
+    type RawValue = [u8];
 }
 
 impl TypeMetadata for Pg {

diesel/src/migrations/mod.rs

@@ -67,6 +67,7 @@ use self::migration::*;
 use self::migration_error::MigrationError::*;
 use self::schema::NewMigration;
 use self::schema::__diesel_schema_migrations::dsl::*;
+use types::{FromSql, VarChar};
 use {Connection, QueryResult};
 
 use std::collections::HashSet;
@@ -86,7 +87,10 @@ use std::path::{PathBuf, Path};
 ///
 /// See the [module level documentation](index.html) for information on how migrations should be
 /// structured, and where Diesel will look for them by default.
-pub fn run_pending_migrations<Conn: Connection>(conn: &Conn) -> Result<(), RunMigrationsError> {
+pub fn run_pending_migrations<Conn>(conn: &Conn) -> Result<(), RunMigrationsError> where
+    Conn: Connection,
+    String: FromSql<VarChar, Conn::Backend>,
+{
     try!(create_schema_migrations_table_if_needed(conn));
     let already_run = try!(previously_run_migration_versions(conn));
     let migrations_dir = try!(find_migrations_directory());
@@ -102,7 +106,10 @@ pub fn run_pending_migrations<Conn: Connection>(conn: &Conn) -> Result<(), RunMi
 ///
 /// See the [module level documentation](index.html) for information on how migrations should be
 /// structured, and where Diesel will look for them by default.
-pub fn revert_latest_migration<Conn: Connection>(conn: &Conn) -> Result<String, RunMigrationsError> {
+pub fn revert_latest_migration<Conn>(conn: &Conn) -> Result<String, RunMigrationsError> where
+    Conn: Connection,
+    String: FromSql<VarChar, Conn::Backend>,
+{
     try!(create_schema_migrations_table_if_needed(conn));
     let latest_migration_version = try!(latest_run_migration_version(conn));
     revert_migration_with_version(conn, &latest_migration_version)
@@ -145,13 +152,19 @@ pub fn create_schema_migrations_table_if_needed<Conn: Connection>(conn: &Conn) -
     })
 }
 
-fn previously_run_migration_versions<Conn: Connection>(conn: &Conn) -> QueryResult<HashSet<String>> {
+fn previously_run_migration_versions<Conn>(conn: &Conn) -> QueryResult<HashSet<String>> where
+    Conn: Connection,
+    String: FromSql<VarChar, Conn::Backend>,
+{
     __diesel_schema_migrations.select(version)
         .load(conn)
         .map(|r| r.collect())
 }
 
-fn latest_run_migration_version<Conn: Connection>(conn: &Conn) -> QueryResult<String> {
+fn latest_run_migration_version<Conn>(conn: &Conn) -> QueryResult<String> where
+    Conn: Connection,
+    String: FromSql<VarChar, Conn::Backend>,
+{
     use ::expression::dsl::max;
     __diesel_schema_migrations.select(max(version))
         .first(conn)

diesel/src/row.rs

@@ -1,7 +1,8 @@
+use backend::{Backend, Pg};
 use db_result::PgResult;
 
-pub trait Row {
-    fn take(&mut self) -> Option<&[u8]>;
+pub trait Row<DB: Backend> {
+    fn take(&mut self) -> Option<&DB::RawValue>;
     fn next_is_null(&self, count: usize) -> bool;
 }
 
@@ -21,7 +22,7 @@ impl<'a> PgRow<'a> {
     }
 }
 
-impl<'a> Row for PgRow<'a> {
+impl<'a> Row<Pg> for PgRow<'a> {
     fn take(&mut self) -> Option<&[u8]> {
         let current_idx = self.col_idx;
         self.col_idx += 1;

diesel/src/types/impls/array.rs

@@ -67,7 +67,7 @@ impl<T, ST> FromSqlRow<Array<ST>, Pg> for Vec<T> where
     Pg: HasSqlType<ST>,
     Vec<T>: FromSql<Array<ST>, Pg>,
 {
-    fn build_from_row<R: Row>(row: &mut R) -> Result<Self, Box<Error>> {
+    fn build_from_row<R: Row<Pg>>(row: &mut R) -> Result<Self, Box<Error>> {
         FromSql::<Array<ST>, Pg>::from_sql(row.take())
     }
 }

diesel/src/types/impls/floats/mod.rs

@@ -1,7 +1,7 @@
 extern crate byteorder;
 
 use std::error::Error;
-use std::io::Write;
+use std::io::prelude::*;
 
 use backend::Backend;
 use self::byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
@@ -11,7 +11,7 @@ use types::{self, FromSql, ToSql, IsNull};
 #[cfg(feature = "quickcheck")]
 mod quickcheck_impls;
 
-impl<DB: Backend> FromSql<types::Float, DB> for f32 {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::Float, DB> for f32 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let mut bytes = not_none!(bytes);
         bytes.read_f32::<BigEndian>().map_err(|e| Box::new(e) as Box<Error>)
@@ -26,7 +26,7 @@ impl<DB: Backend> ToSql<types::Float, DB> for f32 {
     }
 }
 
-impl<DB: Backend> FromSql<types::Double, DB> for f64 {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::Double, DB> for f64 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let mut bytes = not_none!(bytes);
         bytes.read_f64::<BigEndian>().map_err(|e| Box::new(e) as Box<Error>)

diesel/src/types/impls/integers.rs

@@ -1,14 +1,14 @@
 extern crate byteorder;
 
 use std::error::Error;
-use std::io::Write;
+use std::io::prelude::*;
 
 use backend::{Backend, Pg};
 use self::byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
 use super::option::UnexpectedNullError;
 use types::{self, FromSql, ToSql, IsNull};
 
-impl<DB: Backend> FromSql<types::SmallInt, DB> for i16 {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::SmallInt, DB> for i16 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let mut bytes = not_none!(bytes);
         bytes.read_i16::<BigEndian>().map_err(|e| Box::new(e) as Box<Error>)
@@ -23,7 +23,7 @@ impl<DB: Backend> ToSql<types::SmallInt, DB> for i16 {
     }
 }
 
-impl<DB: Backend> FromSql<types::Integer, DB> for i32 {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::Integer, DB> for i32 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let mut bytes = not_none!(bytes);
         bytes.read_i32::<BigEndian>().map_err(|e| Box::new(e) as Box<Error>)
@@ -38,7 +38,7 @@ impl<DB: Backend> ToSql<types::Integer, DB> for i32 {
     }
 }
 
-impl<DB: Backend> FromSql<types::BigInt, DB> for i64 {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::BigInt, DB> for i64 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let mut bytes = not_none!(bytes);
         bytes.read_i64::<BigEndian>().map_err(|e| Box::new(e) as Box<Error>)

diesel/src/types/impls/mod.rs

@@ -63,7 +63,7 @@ macro_rules! queryable_impls {
             DB: $crate::backend::Backend + $crate::types::HasSqlType<types::$Source>,
             $Target: $crate::types::FromSql<types::$Source, DB>,
         {
-            fn build_from_row<R: $crate::row::Row>(row: &mut R) -> Result<Self, Box<Error>> {
+            fn build_from_row<R: $crate::row::Row<DB>>(row: &mut R) -> Result<Self, Box<Error>> {
                 $crate::types::FromSql::<types::$Source, DB>::from_sql(row.take())
             }
         }
@@ -73,7 +73,7 @@ macro_rules! queryable_impls {
             DB: $crate::backend::Backend + $crate::types::HasSqlType<types::$Source>,
             Option<$Target>: $crate::types::FromSql<types::Nullable<types::$Source>, DB>,
         {
-            fn build_from_row<R: $crate::row::Row>(row: &mut R) -> Result<Self, Box<Error>> {
+            fn build_from_row<R: $crate::row::Row<DB>>(row: &mut R) -> Result<Self, Box<Error>> {
                 $crate::types::FromSql::<types::Nullable<types::$Source>, DB>::from_sql(row.take())
             }
         }

diesel/src/types/impls/option.rs

@@ -20,7 +20,7 @@ impl<T, ST, DB> FromSql<Nullable<ST>, DB> for Option<T> where
     T: FromSql<ST, DB>,
     DB: Backend + HasSqlType<ST>, ST: NotNull,
 {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+    fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self, Box<Error>> {
         match bytes {
             Some(_) => T::from_sql(bytes).map(Some),
             None => Ok(None)

diesel/src/types/impls/primitives.rs

@@ -59,7 +59,7 @@ impl ToSql<types::Bool, Pg> for bool {
     }
 }
 
-impl<DB: Backend> FromSql<types::VarChar, DB> for String {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::VarChar, DB> for String {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
         let bytes = not_none!(bytes);
         String::from_utf8(bytes.into()).map_err(|e| Box::new(e) as Box<Error>)
@@ -87,7 +87,7 @@ impl<DB> FromSql<types::Text, DB> for String where
     DB: Backend,
     String: FromSql<types::VarChar, DB>,
 {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+    fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self, Box<Error>> {
         <Self as FromSql<types::VarChar, DB>>::from_sql(bytes)
     }
 }
@@ -110,8 +110,8 @@ impl<'a, DB> ToSql<types::Text, DB> for &'a str where
     }
 }
 
-impl<DB: Backend> FromSql<types::Binary, DB> for Vec<u8> {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+impl<DB: Backend<RawValue=[u8]>> FromSql<types::Binary, DB> for Vec<u8> {
+    fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self, Box<Error>> {
         Ok(not_none!(bytes).into())
     }
 }
@@ -152,7 +152,7 @@ impl<'a, T: ?Sized, ST, DB> FromSql<ST, DB> for Cow<'a, T> where
     DB: Backend + HasSqlType<ST>,
     T::Owned: FromSql<ST, DB>,
 {
-    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error>> {
+    fn from_sql(bytes: Option<&DB::RawValue>) -> Result<Self, Box<Error>> {
         T::Owned::from_sql(bytes).map(Cow::Owned)
     }
 }
@@ -162,7 +162,7 @@ impl <'a, T: ?Sized, ST, DB> ::types::FromSqlRow<ST, DB> for Cow<'a, T> where
     DB: Backend + HasSqlType<ST>,
     Cow<'a, T>: FromSql<ST, DB>,
 {
-    fn build_from_row<R: ::row::Row>(row: &mut R) -> Result<Self, Box<Error>> {
+    fn build_from_row<R: ::row::Row<DB>>(row: &mut R) -> Result<Self, Box<Error>> {
         FromSql::<ST, DB>::from_sql(row.take())
     }
 }

diesel/src/types/impls/tuples.rs

@@ -38,7 +38,7 @@ macro_rules! tuple_impls {
                 $(DB: HasSqlType<$ST>),+,
                 DB: HasSqlType<($($ST,)+)>,
             {
-                fn build_from_row<RowT: Row>(row: &mut RowT) -> Result<Self, Box<Error>> {
+                fn build_from_row<RowT: Row<DB>>(row: &mut RowT) -> Result<Self, Box<Error>> {
                     Ok(($(try!($T::build_from_row(row)),)+))
                 }
             }
@@ -49,7 +49,7 @@ macro_rules! tuple_impls {
                 $(DB: HasSqlType<$ST>),+,
                 DB: HasSqlType<($($ST,)+)>,
             {
-                fn build_from_row<RowT: Row>(row: &mut RowT) -> Result<Self, Box<Error>> {
+                fn build_from_row<RowT: Row<DB>>(row: &mut RowT) -> Result<Self, Box<Error>> {
                     if e!(row.next_is_null($Tuple)) {
                         Ok(None)
                     } else {