Remove the associated type from SelectableExpression

This removes the flawed "SQL type varies based on the query source"
design in favor of "things become nullable if they're on the wrong side
of an outer join". This means that columns from the right side of a left
join can no longer directly be selected. `.nullable` must be manually
called. This sounds like a huge deal, but that's already the case today
with tuples (which is a more common case), and it hasn't caused a huge
ergonomics issue. Ultimately most queries just use the default select
clause.

This also causes the nullability to bubble up. If you're building a
compound expression that involves a column from the right side of a left
join, you don't have to worry about that in the compound expression. You
just have to make the whole thing nullable at the top level. This
mirrors SQL's semantics quite nicely.

One downside of this is that `.nullable` can no longer be used in
arbitrary select clauses. Doing so is questionably useful at best, but
I'd still like to bring back that support in the future. Ultimately
doing so more requires rust-lang/rust#40097 or
similar.

Author: sgrif

diesel/src/expression/array_comparison.rs

@@ -191,7 +191,6 @@ impl<T, QS> SelectableExpression<QS> for Many<T> where
     Many<T>: AppearsOnTable<QS>,
     T: SelectableExpression<QS>,
 {
-    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 impl<T, QS> AppearsOnTable<QS> for Many<T> where
@@ -247,7 +246,6 @@ impl<T, ST, QS> SelectableExpression<QS> for Subselect<T, ST> where
     Subselect<T, ST>: AppearsOnTable<QS>,
     T: Query,
 {
-    type SqlTypeForSelect = ST;
 }
 
 impl<T, ST, QS> AppearsOnTable<QS> for Subselect<T, ST> where

diesel/src/expression/bound.rs

@@ -66,7 +66,6 @@ impl<T: QueryId, U> QueryId for Bound<T, U> {
 impl<T, U, QS> SelectableExpression<QS> for Bound<T, U> where
     Bound<T, U>: AppearsOnTable<QS>,
 {
-    type SqlTypeForSelect = T;
 }
 
 impl<T, U, QS> AppearsOnTable<QS> for Bound<T, U> where

diesel/src/expression/coerce.rs

@@ -41,7 +41,6 @@ impl<T, ST> Expression for Coerce<T, ST> where
 impl<T, ST, QS> SelectableExpression<QS> for Coerce<T, ST> where
     T: SelectableExpression<QS>,
 {
-    type SqlTypeForSelect = Self::SqlType;
 }
 
 impl<T, ST, QS> AppearsOnTable<QS> for Coerce<T, ST> where

diesel/src/expression/expression_methods/global_expression_methods.rs

@@ -286,7 +286,7 @@ pub trait ExpressionMethods: Expression + Sized {
     /// # fn main() {
     /// #     use self::users::dsl::*;
     /// #     let order = "name";
-    /// let ordering: Box<BoxableExpression<users, DB, SqlType=(), SqlTypeForSelect=()>> =
+    /// let ordering: Box<BoxableExpression<users, DB, SqlType=()>> =
     ///     if order == "name" {
     ///         Box::new(name.desc())
     ///     } else {

diesel/src/expression/functions/mod.rs

@@ -62,13 +62,9 @@ macro_rules! sql_function_body {
 
         #[allow(non_camel_case_types)]
         impl<$($arg_name),*, QS> $crate::expression::SelectableExpression<QS> for $struct_name<$($arg_name),*> where
-            $($arg_name: $crate::expression::SelectableExpression<
-              QS,
-              SqlTypeForSelect = <$arg_name as $crate::expression::Expression>::SqlType,
-            >,)*
+            $($arg_name: $crate::expression::SelectableExpression<QS>,)*
             $struct_name<$($arg_name),*>: $crate::expression::AppearsOnTable<QS>,
         {
-            type SqlTypeForSelect = Self::SqlType;
         }
 
         #[allow(non_camel_case_types)]
@@ -143,7 +139,6 @@ macro_rules! no_arg_sql_function_body_except_to_sql {
         }
 
         impl<QS> $crate::expression::SelectableExpression<QS> for $type_name {
-            type SqlTypeForSelect = $return_type;
         }
 
         impl<QS> $crate::expression::AppearsOnTable<QS> for $type_name {

diesel/src/expression/mod.rs

@@ -123,30 +123,27 @@ impl<'a, T: ?Sized, QS> AppearsOnTable<QS> for &'a T where
 {
 }
 
-/// Indicates that an expression can be selected from a source. The associated
-/// type is usually the same as `Expression::SqlType`, but is used to indicate
-/// that a column is always nullable when it appears on the right side of a left
-/// outer join, even if it wasn't nullable to begin with.
+/// Indicates that an expression can be selected from a source. Columns will
+/// implement this for their table. Certain special types, like `CountStar` and
+/// `Bound` will implement this for all sources. Most compound expressions will
+/// implement this if each of their parts implement it.
 ///
-/// Columns will implement this for their table. Certain special types, like
-/// `CountStar` and `Bound` will implement this for all sources. All other
-/// expressions will inherit this from their children.
+/// Notably, columns will not implement this trait for the right side of a left
+/// join. To select a column or expression using a column from the right side of
+/// a left join, you must call `.nullable()` on it.
 pub trait SelectableExpression<QS: ?Sized>: AppearsOnTable<QS> {
-    type SqlTypeForSelect;
 }
 
 impl<T: ?Sized, QS> SelectableExpression<QS> for Box<T> where
     T: SelectableExpression<QS>,
     Box<T>: AppearsOnTable<QS>,
 {
-    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 impl<'a, T: ?Sized, QS> SelectableExpression<QS> for &'a T where
     T: SelectableExpression<QS>,
     &'a T: AppearsOnTable<QS>,
 {
-    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 /// Marker trait to indicate that an expression does not include any aggregate
@@ -184,7 +181,7 @@ impl<QS, T, DB> BoxableExpression<QS, DB> for T where
 {
 }
 
-impl<QS, ST, STS, DB> QueryId for BoxableExpression<QS, DB, SqlType=ST, SqlTypeForSelect=STS> {
+impl<QS, ST, DB> QueryId for BoxableExpression<QS, DB, SqlType=ST> {
     type QueryId = ();
 
     fn has_static_query_id() -> bool {

diesel/src/expression/nullable.rs

@@ -37,16 +37,8 @@ impl<T, DB> QueryFragment<DB> for Nullable<T> where
     }
 }
 
-/// This impl relies on the fact that the only time `T::SqlType` will differ
-/// from `T::SqlTypeForSelect` is to make the right side of a left join become
-/// nullable.
-impl<T, QS> SelectableExpression<QS> for Nullable<T> where
-    T: SelectableExpression<QS>,
-    Nullable<T>: AppearsOnTable<QS>,
-{
-    type SqlTypeForSelect = Self::SqlType;
-}
-
+/// Nullable can be used in where clauses everywhere, but can only be used in
+/// select clauses for outer joins.
 impl<T, QS> AppearsOnTable<QS> for Nullable<T> where
     T: AppearsOnTable<QS>,
     Nullable<T>: Expression,

diesel/src/expression/sql_literal.rs

@@ -52,7 +52,6 @@ impl<ST> Query for SqlLiteral<ST> {
 }
 
 impl<QS, ST> SelectableExpression<QS> for SqlLiteral<ST> {
-    type SqlTypeForSelect = ST;
 }
 
 impl<QS, ST> AppearsOnTable<QS> for SqlLiteral<ST> {

diesel/src/lib.rs

@@ -76,8 +76,8 @@ pub mod helper_types {
     use super::expression::helper_types::Eq;
 
     /// Represents the return type of `.select(selection)`
-    pub type Select<Source, Selection, Type = <Selection as super::Expression>::SqlType> =
-        <Source as SelectDsl<Selection, Type>>::Output;
+    pub type Select<Source, Selection> =
+        <Source as SelectDsl<Selection>>::Output;
 
     /// Represents the return type of `.filter(predicate)`
     pub type Filter<Source, Predicate> =

diesel/src/macros/internal.rs

@@ -22,12 +22,8 @@ macro_rules! impl_selectable_expression {
         impl<$($ty_params,)* QS> $crate::expression::SelectableExpression<QS>
             for $struct_ty where
                 $struct_ty: $crate::expression::AppearsOnTable<QS>,
-                $($ty_params: $crate::expression::SelectableExpression<
-                  QS,
-                  SqlTypeForSelect = <$ty_params as $crate::expression::Expression>::SqlType,
-                >,)*
+                $($ty_params: $crate::expression::SelectableExpression<QS>,)*
         {
-            type SqlTypeForSelect = <$struct_ty as $crate::expression::Expression>::SqlType;
         }
 
         impl<$($ty_params,)* QS> $crate::expression::AppearsOnTable<QS>