Remove the HasSqlType bound everywhere it's not required

Back in 0.4, this was a trait called `NativeSqlType`. I stuck it as a
bound on virtually every place a SQL type was expected, since it served
as nice documentation for "the set of types you can use here". It lived
on things like `Query` and `Expression` as well.

In 0.5 we added support for SQLite, and things got considerably more
complex. This trait could no longer appear in places that the backend
doesn't, and the "implementors" section is much more noisy and no longer
useful documentation of "what are the SQL types".

Ultimately this trait has a single concrete use, and that is to get the
metadata associated with bind parameters. So `BindCollector` needs it,
`AstPass` needs it on the methods that interact there, and `Bound` will
need it in its `QueryFragment` impl. Virtually every other place that
has that bound doesn't need it, and requiring it usually just means "oh
I have to stick this additional useless bound here that I don't know or
understand". Really the annoyance that made me want this is that you
usually wouldn't even import the trait otherwise.

One point to note here is that I was unable to remove this bound from
the `Connection` trait. This is because the MySQL connection is actually
using this bound to tell the C API what type we expect the results to
be. If I change the code to do the same thing we do for `sql_query`,
where we simply ask the database for the result types, we learn that
MySQL does a lot of things differently than we expected:

- 32 bit addition/subtraction returns a 64 bit integer
- 32 bit multiplication/division returns numeric
- 32 bit sum returns numeric
- 32 bit bind parameters are converted to 64 bit

So it turns out that we're relying on the client library to do implicit
coercion in more places than we should be. Ultimately we're going to
need to start doing those conversions ourselves if we ever want to dump
the C API. Once we start doing that, we can remove `HasSqlType` from
`Connection` (and thus also from `LoadQuery`), and then we can deprecate
the `row_metadata` method from that trait.

Author: sgrif

diesel/src/expression/functions/aggregate_folding.rs

@@ -2,7 +2,7 @@ use backend::Backend;
 use expression::Expression;
 use query_builder::*;
 use result::QueryResult;
-use types::{Foldable, HasSqlType};
+use types::Foldable;
 
 macro_rules! fold_function {
     ($fn_name:ident, $type_name:ident, $operator:expr, $docs:expr) => {
@@ -31,7 +31,7 @@ macro_rules! fold_function {
 
         impl<T, DB> QueryFragment<DB> for $type_name<T> where
             T: Expression + QueryFragment<DB>,
-            DB: Backend + HasSqlType<T::SqlType>,
+            DB: Backend,
         {
             fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
                 out.push_sql(concat!($operator, "("));

diesel/src/expression/functions/aggregate_ordering.rs

@@ -2,7 +2,7 @@ use backend::Backend;
 use expression::Expression;
 use query_builder::*;
 use result::QueryResult;
-use types::{HasSqlType, IntoNullable, SqlOrd};
+use types::{IntoNullable, SqlOrd};
 
 macro_rules! ord_function {
     ($fn_name:ident, $type_name:ident, $operator:expr, $docs:expr) => {
@@ -30,7 +30,7 @@ macro_rules! ord_function {
 
         impl<T, DB> QueryFragment<DB> for $type_name<T> where
             T: Expression + QueryFragment<DB>,
-            DB: Backend + HasSqlType<T::SqlType>,
+            DB: Backend,
         {
             fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
                 out.push_sql(concat!($operator, "("));

diesel/src/expression/sql_literal.rs

@@ -5,7 +5,6 @@ use expression::*;
 use query_builder::*;
 use query_dsl::RunQueryDsl;
 use result::QueryResult;
-use types::HasSqlType;
 
 #[derive(Debug, Clone)]
 /// Returned by the [`sql()`] function.
@@ -32,7 +31,7 @@ impl<ST> Expression for SqlLiteral<ST> {
 
 impl<ST, DB> QueryFragment<DB> for SqlLiteral<ST>
 where
-    DB: Backend + HasSqlType<ST>,
+    DB: Backend,
 {
     fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();

diesel/src/mysql/types/numeric.rs

@@ -5,11 +5,11 @@ pub mod bigdecimal {
     use std::error::Error;
     use std::io::prelude::*;
 
-    use mysql::{Mysql, MysqlType};
+    use mysql::Mysql;
 
     use self::bigdecimal::BigDecimal;
 
-    use types::{self, FromSql, HasSqlType, IsNull, ToSql, ToSqlOutput};
+    use types::{self, FromSql, IsNull, ToSql, ToSqlOutput};
 
     impl ToSql<types::Numeric, Mysql> for BigDecimal {
         fn to_sql<W: Write>(
@@ -29,10 +29,4 @@ pub mod bigdecimal {
                 .ok_or_else(|| Box::from(format!("{:?} is not valid decimal number ", bytes)))
         }
     }
-
-    impl HasSqlType<BigDecimal> for Mysql {
-        fn metadata(_: &()) -> MysqlType {
-            MysqlType::String
-        }
-    }
 }

diesel/src/pg/connection/cursor.rs

@@ -4,7 +4,7 @@ use result::Error::DeserializationError;
 use result::QueryResult;
 use super::result::PgResult;
 use super::row::PgNamedRow;
-use types::{FromSqlRow, HasSqlType};
+use types::FromSqlRow;
 
 use std::marker::PhantomData;
 
@@ -29,7 +29,6 @@ impl<ST, T> Cursor<ST, T> {
 
 impl<ST, T> Iterator for Cursor<ST, T>
 where
-    Pg: HasSqlType<ST>,
     T: Queryable<ST, Pg>,
 {
     type Item = QueryResult<T>;

diesel/src/pg/types/array.rs

@@ -25,7 +25,6 @@ impl<T> SingleValue for Array<T> {}
 impl<T, ST> FromSql<Array<ST>, Pg> for Vec<T>
 where
     T: FromSql<ST, Pg>,
-    Pg: HasSqlType<ST>,
 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
         let mut bytes = not_none!(bytes);
@@ -67,9 +66,7 @@ use expression::bound::Bound;
 
 macro_rules! array_as_expression {
     ($ty:ty, $sql_type:ty) => {
-        impl<'a, 'b, ST, T> AsExpression<$sql_type> for $ty where
-            Pg: HasSqlType<ST>,
-        {
+        impl<'a, 'b, ST, T> AsExpression<$sql_type> for $ty {
             type Expression = Bound<$sql_type, Self>;
 
             fn as_expression(self) -> Self::Expression {
@@ -128,7 +125,6 @@ where
 
 impl<ST, T> ToSql<Nullable<Array<ST>>, Pg> for [T]
 where
-    Pg: HasSqlType<ST>,
     [T]: ToSql<Array<ST>, Pg>,
 {
     fn to_sql<W: Write>(
@@ -141,7 +137,6 @@ where
 
 impl<ST, T> ToSql<Array<ST>, Pg> for Vec<T>
 where
-    Pg: HasSqlType<ST>,
     [T]: ToSql<Array<ST>, Pg>,
     T: fmt::Debug,
 {
@@ -155,7 +150,6 @@ where
 
 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>(

diesel/src/pg/types/ranges.rs

@@ -26,51 +26,38 @@ bitflags! {
 impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>)
 where
     T: FromSql<ST, Pg> + Queryable<ST, Pg>,
-    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>,
 {
     type Row = Self;
     fn build(row: Self) -> Self {
         row
     }
 }
 
-impl<ST, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>)
-where
-    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>,
-{
+impl<ST, T> AsExpression<Range<ST>> for (Bound<T>, Bound<T>) {
     type Expression = SqlBound<Range<ST>, Self>;
 
     fn as_expression(self) -> Self::Expression {
         SqlBound::new(self)
     }
 }
 
-impl<'a, ST, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>)
-where
-    Pg: HasSqlType<Range<ST>>,
-{
+impl<'a, ST, T> AsExpression<Range<ST>> for &'a (Bound<T>, Bound<T>) {
     type Expression = SqlBound<Range<ST>, Self>;
 
     fn as_expression(self) -> Self::Expression {
         SqlBound::new(self)
     }
 }
 
-impl<ST, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>)
-where
-    Pg: HasSqlType<Range<ST>>,
-{
+impl<ST, T> AsExpression<Nullable<Range<ST>>> for (Bound<T>, Bound<T>) {
     type Expression = SqlBound<Nullable<Range<ST>>, Self>;
 
     fn as_expression(self) -> Self::Expression {
         SqlBound::new(self)
     }
 }
 
-impl<'a, ST, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>)
-where
-    Pg: HasSqlType<Range<ST>>,
-{
+impl<'a, ST, T> AsExpression<Nullable<Range<ST>>> for &'a (Bound<T>, Bound<T>) {
     type Expression = SqlBound<Nullable<Range<ST>>, Self>;
 
     fn as_expression(self) -> Self::Expression {
@@ -81,7 +68,6 @@ where
 impl<T, ST> FromSqlRow<Range<ST>, Pg> for (Bound<T>, Bound<T>)
 where
     (Bound<T>, Bound<T>): FromSql<Range<ST>, Pg>,
-    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>,
 {
     fn build_from_row<R: ::row::Row<Pg>>(row: &mut R) -> Result<Self, Box<Error + Send + Sync>> {
         FromSql::<Range<ST>, Pg>::from_sql(row.take())
@@ -91,7 +77,6 @@ where
 impl<T, ST> FromSql<Range<ST>, Pg> for (Bound<T>, Bound<T>)
 where
     T: FromSql<ST, Pg>,
-    Pg: HasSqlType<ST> + HasSqlType<Range<ST>>,
 {
     fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {
         let mut bytes = not_none!(bytes);
@@ -129,7 +114,6 @@ where
 
 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>(
@@ -178,7 +162,6 @@ where
 
 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>(

diesel/src/query_builder/select_statement/boxed.rs

@@ -14,7 +14,7 @@ use query_dsl::methods::*;
 use query_source::QuerySource;
 use query_source::joins::*;
 use result::QueryResult;
-use types::{BigInt, Bool, HasSqlType};
+use types::{BigInt, Bool};
 
 #[allow(missing_debug_implementations)]
 pub struct BoxedSelectStatement<'a, ST, QS, DB> {
@@ -58,7 +58,6 @@ impl<'a, ST, QS, DB> BoxedSelectStatement<'a, ST, QS, DB> {
 impl<'a, ST, QS, DB> Query for BoxedSelectStatement<'a, ST, QS, DB>
 where
     DB: Backend,
-    DB: HasSqlType<ST>,
 {
     type SqlType = ST;
 }
@@ -166,7 +165,7 @@ where
 
 impl<'a, ST, QS, DB, Selection> SelectDsl<Selection> for BoxedSelectStatement<'a, ST, QS, DB>
 where
-    DB: Backend + HasSqlType<Selection::SqlType>,
+    DB: Backend,
     Selection: SelectableExpression<QS> + QueryFragment<DB> + 'a,
 {
     type Output = BoxedSelectStatement<'a, Selection::SqlType, QS, DB>;
@@ -187,7 +186,7 @@ where
 
 impl<'a, ST, QS, DB, Predicate> FilterDsl<Predicate> for BoxedSelectStatement<'a, ST, QS, DB>
 where
-    DB: Backend + HasSqlType<ST> + 'a,
+    DB: Backend + 'a,
     Predicate: AppearsOnTable<QS, SqlType = Bool> + NonAggregate,
     Predicate: QueryFragment<DB> + 'a,
 {

diesel/src/query_source/mod.rs

@@ -13,7 +13,7 @@ use backend::Backend;
 use expression::{Expression, NonAggregate, SelectableExpression};
 use query_builder::*;
 use row::NamedRow;
-use types::{FromSqlRow, HasSqlType};
+use types::FromSqlRow;
 
 pub use self::joins::JoinTo;
 pub use self::peano_numbers::*;
@@ -108,7 +108,7 @@ pub use self::peano_numbers::*;
 /// # }
 pub trait Queryable<ST, DB>
 where
-    DB: Backend + HasSqlType<ST>,
+    DB: Backend,
 {
     /// The Rust type you'd like to map from.
     ///
@@ -123,7 +123,7 @@ where
 //
 // impl<T, ST, DB> Queryable<ST, DB> for T
 // where
-//     DB: Backend + HasSqlType<ST>,
+//     DB: Backend,
 //     T: FromSqlRow<ST, DB>,
 // {
 //     type Row = Self;

diesel/src/row.rs

@@ -3,7 +3,7 @@
 use std::error::Error;
 
 use backend::Backend;
-use types::{FromSql, HasSqlType};
+use types::FromSql;
 
 /// Represents a single database row.
 /// Apps should not need to concern themselves with this trait.
@@ -48,7 +48,6 @@ pub trait NamedRow<DB: Backend> {
     /// this function is undefined.
     fn get<ST, T>(&self, column_name: &str) -> Result<T, Box<Error + Send + Sync>>
     where
-        DB: HasSqlType<ST>,
         T: FromSql<ST, DB>,
     {
         let idx = self.index_of(column_name)