Remove Expression#to_sql

This method was entirely redundant with `QueryFragment#to_sql`, and
effectively only exists because `Expression` predates `QueryFragment`,
and I needed to be able to sometimes call `to_insert_sql`. Any cases
that couldn't be covered previously have been removed.

With this change, our heirarchy is much more clear. `QueryFragment`
represents a thing that can be converted to SQL. `Expression` represents
something that represents a SQL type. `Query` represents a typed
`QueryFragment` that can be meaningfully executed.

`Expression` does not have `QueryFragment` as a constraint, but it is
implied that implementing one means you'd implement the other. The
reason I did not add this constraint was that I ultimately intend to
make `QueryFragment` generic over the backend, and I do not want to deal
with that when talking purely about an `Expression`.

I've tried to loosely audit some of the where clauses to avoid putting
too much "type safety" bits in the where clause for `QueryFragment`
impls, and focus on "can be converted to SQL". It's certainly not done,
but I've tried to at the very least not make it any worse. A lot of this
can get cleaned up when I do a pass to attempt to improve specific error
messages.

I need to explitly document this somewhere, but generally a structure
should have no constraints on types in its definition, type safety
should be enforced in `Query` or `Expression` impls, and/or DSL methods,
and memory/serialization safety should be enforced in `QueryFragment`
impls.

Author: sgrif

diesel/src/expression/aliased.rs

@@ -19,9 +19,15 @@ impl<'a, Expr> Aliased<'a, Expr> {
 
 pub struct FromEverywhere;
 
-impl<'a, T> Expression for Aliased<'a, T> where T: Expression {
+impl<'a, T> Expression for Aliased<'a, T> where
+    T: Expression,
+{
     type SqlType = T::SqlType;
+}
 
+impl<'a, T> QueryFragment for Aliased<'a, T> where
+    T: QueryFragment,
+{
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         out.push_identifier(&self.alias)
     }
@@ -33,7 +39,7 @@ impl<'a, T, QS> SelectableExpression<QS> for Aliased<'a, T> where
 {
 }
 
-impl<'a, T: Expression> QuerySource for Aliased<'a, T> {
+impl<'a, T: Expression + QueryFragment> QuerySource for Aliased<'a, T> {
     fn from_clause(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         try!(self.expr.to_sql(out));
         out.push_sql(" ");

diesel/src/expression/array_comparison.rs

@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 use super::{AsExpression, Expression, SelectableExpression, NonAggregate};
 use types::{Array, NativeSqlType};
 
@@ -61,7 +61,11 @@ impl<Expr, ST> Expression for Any<Expr, ST> where
     Expr: Expression<SqlType=Array<ST>>,
 {
     type SqlType = ST;
+}
 
+impl<Expr, ST> QueryFragment for Any<Expr, ST> where
+    Expr: QueryFragment,
+{
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         out.push_sql("ANY(");
         try!(self.expr.to_sql(out));

diesel/src/expression/bound.rs

@@ -16,10 +16,14 @@ impl<T: NativeSqlType, U> Bound<T, U> {
 
 impl<T, U> Expression for Bound<T, U> where
     T: NativeSqlType,
-    U: ToSql<T>,
 {
     type SqlType = T;
+}
 
+impl<T, U> QueryFragment for Bound<T, U> where
+    T: NativeSqlType,
+    U: ToSql<T>,
+{
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         let mut bytes = Vec::new();
         match try!(self.item.to_sql(&mut bytes)) {

diesel/src/expression/count.rs

@@ -1,4 +1,4 @@
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 use super::{Expression, SelectableExpression};
 use types::BigInt;
 
@@ -46,13 +46,15 @@ pub fn count_star() -> CountStar {
 
 #[derive(Debug, Clone, Copy)]
 #[doc(hidden)]
-pub struct Count<T: Expression> {
+pub struct Count<T> {
     target: T,
 }
 
 impl<T: Expression> Expression for Count<T> {
     type SqlType = BigInt;
+}
 
+impl<T: QueryFragment> QueryFragment for Count<T> {
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         out.push_sql("COUNT(");
         try!(self.target.to_sql(out));
@@ -70,7 +72,9 @@ pub struct CountStar;
 
 impl Expression for CountStar {
     type SqlType = BigInt;
+}
 
+impl QueryFragment for CountStar {
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         out.push_sql("COUNT(*)");
         Ok(())

diesel/src/expression/date_and_time.rs

@@ -1,5 +1,5 @@
 use expression::{Expression, SelectableExpression};
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 use types::{Timestamp, VarChar};
 
 pub struct AtTimeZone<Ts, Tz> {
@@ -22,7 +22,12 @@ impl<Ts, Tz> Expression for AtTimeZone<Ts, Tz> where
 {
     // FIXME: This should be Timestamptz when we support that type
     type SqlType = Timestamp;
+}
 
+impl<Ts, Tz> QueryFragment for AtTimeZone<Ts, Tz> where
+    Ts: QueryFragment,
+    Tz: QueryFragment,
+{
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         try!(self.timestamp.to_sql(out));
         out.push_sql(" AT TIME ZONE ");
@@ -32,4 +37,6 @@ impl<Ts, Tz> Expression for AtTimeZone<Ts, Tz> where
 
 impl<Ts, Tz, Qs> SelectableExpression<Qs> for AtTimeZone<Ts, Tz> where
     AtTimeZone<Ts, Tz>: Expression,
+    Ts: SelectableExpression<Qs>,
+    Tz: SelectableExpression<Tz>,
 {}

diesel/src/expression/functions/aggregate_ordering.rs

@@ -1,5 +1,5 @@
 use expression::{Expression, SelectableExpression};
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 use types::{SqlOrd, NativeSqlType};
 
 macro_rules! ord_function {
@@ -15,13 +15,15 @@ macro_rules! ord_function {
         }
 
         #[derive(Debug, Clone, Copy)]
-        pub struct $type_name<T: Expression> {
+        pub struct $type_name<T> {
             target: T,
         }
 
         impl<T: Expression> Expression for $type_name<T> {
             type SqlType = T::SqlType;
+        }
 
+        impl<T: QueryFragment> QueryFragment for $type_name<T> {
             fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
                 out.push_sql(concat!($operator, "("));
                 try!(self.target.to_sql(out));

diesel/src/expression/functions/mod.rs

@@ -31,11 +31,16 @@ macro_rules! sql_function_body {
             for <'a> ($(&'a $arg_name),*): $crate::expression::Expression,
         {
             type SqlType = $return_type;
+        }
 
+        #[allow(non_camel_case_types)]
+        impl<$($arg_name),*> $crate::query_builder::QueryFragment for $struct_name<$($arg_name),*> where
+            for <'a> ($(&'a $arg_name),*): $crate::query_builder::QueryFragment,
+        {
             fn to_sql(&self, out: &mut $crate::query_builder::QueryBuilder)
                 -> $crate::query_builder::BuildQueryResult {
                     out.push_sql(concat!(stringify!($fn_name), "("));
-                    try!($crate::expression::Expression::to_sql(
+                    try!($crate::query_builder::QueryFragment::to_sql(
                         &($(&self.$arg_name),*), out));
                     out.push_sql(")");
                     Ok(())
@@ -107,7 +112,9 @@ macro_rules! no_arg_sql_function_body {
 
         impl $crate::expression::Expression for $type_name {
             type SqlType = $return_type;
+        }
 
+        impl $crate::query_builder::QueryFragment for $type_name {
             fn to_sql(&self, out: &mut $crate::query_builder::QueryBuilder)
                 -> $crate::query_builder::BuildQueryResult {
                     out.push_sql(concat!(stringify!($type_name), "()"));

diesel/src/expression/grouped.rs

@@ -1,11 +1,13 @@
 use expression::{Expression, SelectableExpression, NonAggregate};
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 
 pub struct Grouped<T>(pub T);
 
 impl<T: Expression> Expression for Grouped<T> {
     type SqlType = T::SqlType;
+}
 
+impl<T: QueryFragment> QueryFragment for Grouped<T> {
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         out.push_sql("(");
         try!(self.0.to_sql(out));

diesel/src/expression/mod.rs

@@ -58,7 +58,6 @@ pub mod dsl {
 pub use self::dsl::*;
 pub use self::sql_literal::SqlLiteral;
 
-use query_builder::{QueryBuilder, BuildQueryResult};
 use types::NativeSqlType;
 
 /// Represents a typed fragment of SQL. Apps should not need to implement this
@@ -69,24 +68,14 @@ use types::NativeSqlType;
 /// implementing this directly.
 pub trait Expression {
     type SqlType: NativeSqlType;
-
-    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult;
 }
 
 impl<T: Expression + ?Sized> Expression for Box<T> {
     type SqlType = T::SqlType;
-
-    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
-        Expression::to_sql(&**self, out)
-    }
 }
 
 impl<'a, T: Expression + ?Sized> Expression for &'a T {
     type SqlType = T::SqlType;
-
-    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
-        Expression::to_sql(&**self, out)
-    }
 }
 
 /// Describes how a type can be represented as an expression for a given type.
@@ -152,14 +141,16 @@ impl<T: NonAggregate + ?Sized> NonAggregate for Box<T> {
 impl<'a, T: NonAggregate + ?Sized> NonAggregate for &'a T {
 }
 
+use query_builder::QueryFragment;
+
 /// Helper trait used when boxing expressions. This exists to work around the
 /// fact that Rust will not let us use non-core types as bounds on a trait
 /// object (you could not return `Box<Expression+NonAggregate>`)
-pub trait BoxableExpression<QS, ST: NativeSqlType>: Expression + SelectableExpression<QS, ST> + NonAggregate {
+pub trait BoxableExpression<QS, ST: NativeSqlType>: Expression + SelectableExpression<QS, ST> + NonAggregate + QueryFragment {
 }
 
 impl<QS, T, ST> BoxableExpression<QS, ST> for T where
     ST: NativeSqlType,
-    T: Expression + SelectableExpression<QS, ST> + NonAggregate,
+    T: Expression + SelectableExpression<QS, ST> + NonAggregate + QueryFragment,
 {
 }

diesel/src/expression/nullable.rs

@@ -1,5 +1,5 @@
 use expression::{Expression, SelectableExpression, NonAggregate};
-use query_builder::{QueryBuilder, BuildQueryResult};
+use query_builder::*;
 use types::IntoNullable;
 
 pub struct Nullable<T>(T);
@@ -15,7 +15,11 @@ impl<T> Expression for Nullable<T> where
     <T as Expression>::SqlType: IntoNullable,
 {
     type SqlType = <<T as Expression>::SqlType as IntoNullable>::Nullable;
+}
 
+impl<T> QueryFragment for Nullable<T> where
+    T: QueryFragment,
+{
     fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
         self.0.to_sql(out)
     }