Use associated types for SelectableExpression

CHANGELOG.md

@@ -41,6 +41,12 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 
 [transaction-0.11.0]: http://docs.diesel.rs/diesel/connection/trait.Connection.html#method.transaction
 
+* The way tuples of columns from the right side of left outer joins interact
+  with `.select` has changed. If you are deserializing into an option of a tuple
+  (instead of a tuple of options), you will need to explicitly call
+  `.nullable()`. (e.g. `.select(users::name, (posts::title,
+  posts::body).nullable())`)
+
 ### Removed
 
 * `result::TransactionError`

diesel/src/expression/aliased.rs

@@ -20,9 +20,6 @@ impl<'a, Expr> Aliased<'a, Expr> {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
-pub struct FromEverywhere;
-
 impl<'a, T> Expression for Aliased<'a, T> where
     T: Expression,
 {
@@ -57,7 +54,9 @@ impl<'a, T> QueryId for Aliased<'a, T> {
 // FIXME This is incorrect, should only be selectable from WithQuerySource
 impl<'a, T, QS> SelectableExpression<QS> for Aliased<'a, T> where
     Aliased<'a, T>: Expression,
+    T: SelectableExpression<QS>,
 {
+    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 impl<'a, T: Expression + Copy> QuerySource for Aliased<'a, T> {

diesel/src/expression/array_comparison.rs

@@ -57,13 +57,15 @@ impl<T, U, QS> SelectableExpression<QS> for In<T, U> where
     T: SelectableExpression<QS>,
     U: SelectableExpression<QS>,
 {
+    type SqlTypeForSelect = Self::SqlType;
 }
 
 impl<T, U, QS> SelectableExpression<QS> for NotIn<T, U> where
     NotIn<T, U>: Expression,
     T: SelectableExpression<QS>,
     U: SelectableExpression<QS>,
 {
+    type SqlTypeForSelect = Self::SqlType;
 }
 
 impl<T, U> NonAggregate for In<T, U> where
@@ -163,9 +165,10 @@ pub trait MaybeEmpty {
     fn is_empty(&self) -> bool;
 }
 
-impl<ST, S, F, W, O, L, Of> AsInExpression<ST>
-    for SelectStatement<ST, S, F, W, O, L, Of> where
-        Subselect<SelectStatement<ST, S, F, W, O, L, Of>, ST>: Expression<SqlType=ST>,
+impl<ST, S, F, W, O, L, Of, G> AsInExpression<ST>
+    for SelectStatement<S, F, W, O, L, Of, G> where
+        SelectStatement<S, F, W, O, L, Of, G>: Query<SqlType=ST>,
+        Subselect<SelectStatement<S, F, W, O, L, Of>, ST>: Expression,
 {
     type InExpression = Subselect<Self, ST>;
 
@@ -202,6 +205,7 @@ impl<T, QS> SelectableExpression<QS> for Many<T> where
     Many<T>: Expression,
     T: SelectableExpression<QS>,
 {
+    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 impl<T, DB> QueryFragment<DB> for Many<T> where
@@ -251,6 +255,7 @@ impl<T, ST, QS> SelectableExpression<QS> for Subselect<T, ST> where
     Subselect<T, ST>: Expression,
     T: Query,
 {
+    type SqlTypeForSelect = ST;
 }
 
 impl<T, ST, DB> QueryFragment<DB> for Subselect<T, ST> where

diesel/src/expression/bound.rs

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

diesel/src/expression/coerce.rs

@@ -41,6 +41,7 @@ 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, DB> QueryFragment<DB> for Coerce<T, ST> where

diesel/src/expression/count.rs

@@ -80,6 +80,7 @@ impl<T: QueryFragment<DB>, DB: Backend> QueryFragment<DB> for Count<T> {
 impl_query_id!(Count<T>);
 
 impl<T: Expression, QS> SelectableExpression<QS> for Count<T> {
+    type SqlTypeForSelect = BigInt;
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -106,6 +107,7 @@ impl<DB: Backend> QueryFragment<DB> for CountStar {
 }
 
 impl<QS> SelectableExpression<QS> for CountStar {
+    type SqlTypeForSelect = BigInt;
 }
 
 impl_query_id!(CountStar);

diesel/src/expression/exists.rs

@@ -52,6 +52,7 @@ impl<T> Expression for Exists<T> where
 impl<T, QS> SelectableExpression<QS> for Exists<T> where
     Exists<T>: Expression,
 {
+    type SqlTypeForSelect = Bool;
 }
 
 impl<T> NonAggregate for Exists<T> {

diesel/src/expression/expression_methods/global_expression_methods.rs

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

diesel/src/expression/functions/aggregate_folding.rs

@@ -51,10 +51,11 @@ macro_rules! fold_function {
 
         impl_query_id!($type_name<T>);
 
-        impl<ST, T, QS> SelectableExpression<QS> for $type_name<T> where
-            ST: Foldable,
-            T: Expression<SqlType=ST>,
+        impl<T, QS> SelectableExpression<QS> for $type_name<T> where
+            $type_name<T>: Expression,
+            T: SelectableExpression<QS>,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
     }
 }

diesel/src/expression/functions/aggregate_ordering.rs

@@ -52,7 +52,9 @@ macro_rules! ord_function {
 
         impl<T, QS> SelectableExpression<QS> for $type_name<T> where
             $type_name<T>: Expression,
+            T: SelectableExpression<QS>,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
     }
 }

diesel/src/expression/functions/date_and_time.rs

@@ -15,6 +15,7 @@ impl Expression for now {
 }
 
 impl<QS> SelectableExpression<QS> for now {
+    type SqlTypeForSelect = Timestamp;
 }
 
 impl NonAggregate for now {

diesel/src/expression/functions/mod.rs

@@ -65,6 +65,7 @@ macro_rules! sql_function_body {
             $($arg_name: $crate::expression::SelectableExpression<QS>,)*
             $struct_name<$($arg_name),*>: $crate::expression::Expression,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
 
         #[allow(non_camel_case_types)]
@@ -132,6 +133,7 @@ macro_rules! no_arg_sql_function_body_except_to_sql {
         }
 
         impl<QS> $crate::expression::SelectableExpression<QS> for $type_name {
+            type SqlTypeForSelect = $return_type;
         }
 
         impl $crate::expression::NonAggregate for $type_name {

diesel/src/expression/grouped.rs

@@ -34,6 +34,7 @@ impl<T, QS> SelectableExpression<QS> for Grouped<T> where
     T: SelectableExpression<QS>,
     Grouped<T>: Expression,
 {
+    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 impl<T: NonAggregate> NonAggregate for Grouped<T> where

diesel/src/expression/mod.rs

@@ -104,29 +104,30 @@ impl<T: Expression> AsExpression<T::SqlType> for T {
     }
 }
 
-/// Indicates that an expression can be selected from a source. The second type
-/// argument is optional, but is used to indicate that the right side of a left
-/// outer join is nullable, even if it wasn't before.
+/// 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.
 ///
 /// 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.
-pub trait SelectableExpression<
-    QS,
-    Type = <Self as Expression>::SqlType,
->: Expression {
+pub trait SelectableExpression<QS>: Expression {
+    type SqlTypeForSelect;
 }
 
-impl<T: ?Sized, ST, QS> SelectableExpression<QS, ST> for Box<T> where
-    T: SelectableExpression<QS, ST>,
+impl<T: ?Sized, QS> SelectableExpression<QS> for Box<T> where
+    T: SelectableExpression<QS>,
     Box<T>: Expression,
 {
+    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
-impl<'a, T: ?Sized, ST, QS> SelectableExpression<QS, ST> for &'a T where
-    T: SelectableExpression<QS, ST>,
+impl<'a, T: ?Sized, QS> SelectableExpression<QS> for &'a T where
+    T: SelectableExpression<QS>,
     &'a T: Expression,
 {
+    type SqlTypeForSelect = T::SqlTypeForSelect;
 }
 
 /// Marker trait to indicate that an expression does not include any aggregate
@@ -147,24 +148,24 @@ use query_builder::{QueryFragment, QueryId};
 /// 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, DB> where
+pub trait BoxableExpression<QS, DB> where
     DB: Backend,
     Self: Expression,
-    Self: SelectableExpression<QS, ST>,
+    Self: SelectableExpression<QS>,
     Self: NonAggregate,
     Self: QueryFragment<DB>,
 {}
 
-impl<QS, T, ST, DB> BoxableExpression<QS, ST, DB> for T where
+impl<QS, T, DB> BoxableExpression<QS, DB> for T where
     DB: Backend,
     T: Expression,
-    T: SelectableExpression<QS, ST>,
+    T: SelectableExpression<QS>,
     T: NonAggregate,
     T: QueryFragment<DB>,
 {
 }
 
-impl<QS, ST, DB> QueryId for BoxableExpression<QS, ST, DB, SqlType=ST> {
+impl<QS, ST, STS, DB> QueryId for BoxableExpression<QS, DB, SqlType=ST, SqlTypeForSelect=STS> {
     type QueryId = ();
 
     fn has_static_query_id() -> bool {

diesel/src/expression/nullable.rs

@@ -37,10 +37,14 @@ 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>: Expression,
 {
+    type SqlTypeForSelect = Self::SqlType;
 }
 
 impl<T: QueryId> QueryId for Nullable<T> {

diesel/src/expression/ops/numeric.rs

@@ -59,6 +59,7 @@ macro_rules! numeric_operation {
             Rhs: SelectableExpression<QS>,
             $name<Lhs, Rhs>: Expression,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
 
         impl<Lhs, Rhs> NonAggregate for $name<Lhs, Rhs> where

diesel/src/expression/predicates.rs

@@ -30,6 +30,7 @@ macro_rules! infix_predicate_body {
             T: $crate::expression::SelectableExpression<QS>,
             U: $crate::expression::SelectableExpression<QS>,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
 
         impl<T, U> $crate::expression::NonAggregate for $name<T, U> where
@@ -219,6 +220,7 @@ macro_rules! postfix_predicate_body {
         impl<T, QS> $crate::expression::SelectableExpression<QS> for $name<T> where
             T: $crate::expression::SelectableExpression<QS>,
         {
+            type SqlTypeForSelect = Self::SqlType;
         }
 
         impl<T> $crate::expression::NonAggregate for $name<T> where

diesel/src/expression/sql_literal.rs

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

diesel/src/macros/mod.rs

@@ -31,19 +31,24 @@ macro_rules! __diesel_column {
 
         impl_query_id!($column_name);
 
-        impl $crate::expression::SelectableExpression<$($table)::*> for $column_name {}
+        impl $crate::expression::SelectableExpression<$($table)::*> for $column_name {
+            type SqlTypeForSelect = $Type;
+        }
 
-        impl<'a, ST, Left, Right> SelectableExpression<
-            $crate::WithQuerySource<'a, Left, Right>, ST> for $column_name where
-            $column_name: SelectableExpression<Left, ST>
+        impl<'a, Left, Right> SelectableExpression<
+            $crate::WithQuerySource<'a, Left, Right>,
+        > for $column_name where
+            $column_name: SelectableExpression<Left>,
         {
+            type SqlTypeForSelect = $Type;
         }
 
-        impl<ST, Source, Predicate> SelectableExpression<
-            $crate::query_source::filter::FilteredQuerySource<Source, Predicate>, ST>
-            for $column_name where
-                $column_name: SelectableExpression<Source, ST>
+        impl<Source, Predicate> SelectableExpression<
+            $crate::query_source::filter::FilteredQuerySource<Source, Predicate>,
+        > for $column_name where
+            $column_name: SelectableExpression<Source>,
         {
+            type SqlTypeForSelect = $Type;
         }
 
         impl $crate::expression::NonAggregate for $column_name {}
@@ -301,7 +306,7 @@ macro_rules! table_body {
 
             impl AsQuery for table {
                 type SqlType = SqlType;
-                type Query = SelectStatement<SqlType, ($($column_name,)+), Self>;
+                type Query = SelectStatement<($($column_name,)+), Self>;
 
                 fn as_query(self) -> Self::Query {
                     SelectStatement::simple(all_columns, self)
@@ -376,7 +381,9 @@ macro_rules! table_body {
                     }
                 }
 
-                impl SelectableExpression<table> for star {}
+                impl SelectableExpression<table> for star {
+                    type SqlTypeForSelect = Self::SqlType;
+                }
 
                 $(__diesel_column!(table, $column_name -> $column_ty);)+
             }
@@ -485,26 +492,29 @@ macro_rules! select_column_inner {
             $crate::query_source::InnerJoinSource<$child, $parent>,
         > for $column
         {
+            type SqlTypeForSelect = <Self as $crate::Expression>::SqlType;
         }
 
         impl $crate::expression::SelectableExpression<
             $crate::query_source::InnerJoinSource<$parent, $child>,
         > for $column
         {
+            type SqlTypeForSelect = <Self as $crate::Expression>::SqlType;
         }
 
         impl $crate::expression::SelectableExpression<
             $crate::query_source::LeftOuterJoinSource<$child, $parent>,
-            <<$column as $crate::Expression>::SqlType
-                as $crate::types::IntoNullable>::Nullable,
         > for $column
         {
+            type SqlTypeForSelect = <<Self as $crate::Expression>::SqlType
+                as $crate::types::IntoNullable>::Nullable;
         }
 
         impl $crate::expression::SelectableExpression<
             $crate::query_source::LeftOuterJoinSource<$parent, $child>,
         > for $column
         {
+            type SqlTypeForSelect = <Self as $crate::Expression>::SqlType;
         }
     }
 }