Simplify implementation

* Add a method on `QueryDsl` to document the new method
* Change `Nullable<SelectClause<T>>` into `SelectClause<Nullable<T>>`
  because this gives a better implementation (Thanks for the idea
  Sean)
* Do not use internal api's in new tests

Author: weiznich

diesel/src/expression/nullable.rs

@@ -1,7 +1,5 @@
 use backend::Backend;
 use expression::*;
-use query_builder::select_clause::{BoxSelectClause, SelectClauseExpression,
-                                   SelectClauseQueryFragment};
 use query_builder::*;
 use query_source::Table;
 use result::QueryResult;
@@ -56,38 +54,10 @@ where
 {
 }
 
-impl<T, Tab> SelectableExpression<Tab> for Nullable<T>
+impl<T, QS> SelectableExpression<QS> for Nullable<T>
 where
-    Self: AppearsOnTable<Tab>,
-    T: SelectableExpression<Tab>,
-    Tab: Table,
+    Self: AppearsOnTable<QS>,
+    T: SelectableExpression<QS>,
+    QS: Table,
 {
 }
-
-impl<T, QS> SelectClauseExpression<QS> for Nullable<T>
-where
-    T: SelectClauseExpression<QS>,
-    T::SelectClauseSqlType: ::sql_types::NotNull,
-{
-    type SelectClauseSqlType = ::sql_types::Nullable<T::SelectClauseSqlType>;
-}
-
-impl<T, QS, DB> SelectClauseQueryFragment<QS, DB> for Nullable<T>
-where
-    T: SelectClauseQueryFragment<QS, DB>,
-    DB: Backend,
-{
-    fn walk_ast(&self, source: &QS, pass: AstPass<DB>) -> QueryResult<()> {
-        self.0.walk_ast(source, pass)
-    }
-}
-
-impl<'a, QS, DB, T> BoxSelectClause<'a, QS, DB> for Nullable<T>
-where
-    DB: Backend,
-    T: BoxSelectClause<'a, QS, DB>,
-{
-    fn box_select_clause(self, qs: &QS) -> Box<QueryFragment<DB> + 'a> {
-        self.0.box_select_clause(qs)
-    }
-}

diesel/src/lib.rs

@@ -316,6 +316,9 @@ pub mod helper_types {
 
     /// Represents the return type of `.single_value()`
     pub type SingleValue<Source> = <Source as SingleValueDsl>::Output;
+
+    /// Represents the return type of `.nullable()`
+    pub type NullableSelect<Source> = <Source as NullableSelectDsl>::Output;
 }
 
 pub mod prelude {

diesel/src/query_builder/mod.rs

@@ -25,7 +25,7 @@ pub mod nodes;
 mod offset_clause;
 mod order_clause;
 mod returning_clause;
-pub(crate) mod select_clause;
+mod select_clause;
 mod select_statement;
 mod sql_query;
 mod update_statement;
@@ -49,9 +49,6 @@ pub use self::update_statement::IncompleteUpdateStatement;
 pub use self::update_statement::{AsChangeset, BoxedUpdateStatement, IntoUpdateTarget,
                                  UpdateStatement, UpdateTarget};
 
-#[doc(hidden)]
-pub use self::select_clause::BoxSelectClause;
-
 pub(crate) use self::insert_statement::ColumnList;
 
 use std::error::Error;

diesel/src/query_builder/select_clause.rs

@@ -50,29 +50,3 @@ where
         source.default_selection().walk_ast(pass)
     }
 }
-
-#[doc(hidden)]
-pub trait BoxSelectClause<'a, QS, DB: Backend> {
-    fn box_select_clause(self, qs: &QS) -> Box<QueryFragment<DB> + 'a>;
-}
-
-impl<'a, QS, DB, T> BoxSelectClause<'a, QS, DB> for SelectClause<T>
-where
-    DB: Backend,
-    T: QueryFragment<DB> + SelectableExpression<QS> + 'a,
-{
-    fn box_select_clause(self, _: &QS) -> Box<QueryFragment<DB> + 'a> {
-        Box::new(self.0)
-    }
-}
-
-impl<'a, QS, DB> BoxSelectClause<'a, QS, DB> for DefaultSelectClause
-where
-    DB: Backend,
-    QS: QuerySource,
-    QS::DefaultSelection: QueryFragment<DB> + 'a,
-{
-    fn box_select_clause(self, qs: &QS) -> Box<QueryFragment<DB> + 'a> {
-        Box::new(qs.default_selection())
-    }
-}

diesel/src/query_builder/select_statement/boxed.rs

@@ -59,25 +59,6 @@ impl<'a, ST, QS, DB> BoxedSelectStatement<'a, ST, QS, DB> {
     }
 }
 
-impl<'a, ST, QS, DB> BoxedSelectStatement<'a, ST, QS, DB>
-where
-    ST: NotNull,
-{
-    pub fn nullable(self) -> BoxedSelectStatement<'a, Nullable<ST>, QS, DB> {
-        BoxedSelectStatement {
-            select: self.select,
-            from: self.from,
-            distinct: self.distinct,
-            where_clause: self.where_clause,
-            order: self.order,
-            limit: self.limit,
-            offset: self.offset,
-            group_by: self.group_by,
-            _marker: PhantomData,
-        }
-    }
-}
-
 impl<'a, ST, QS, DB> Query for BoxedSelectStatement<'a, ST, QS, DB>
 where
     DB: Backend,
@@ -339,3 +320,24 @@ where
         InsertFromSelect::new(self)
     }
 }
+
+impl<'a, ST, QS, DB> NullableSelectDsl for BoxedSelectStatement<'a, ST, QS, DB>
+where
+    ST: NotNull,
+{
+    type Output = BoxedSelectStatement<'a, Nullable<ST>, QS, DB>;
+
+    fn nullable(self) -> Self::Output {
+        BoxedSelectStatement {
+            select: self.select,
+            from: self.from,
+            distinct: self.distinct,
+            where_clause: self.where_clause,
+            order: self.order,
+            limit: self.limit,
+            offset: self.offset,
+            group_by: self.group_by,
+            _marker: PhantomData,
+        }
+    }
+}

diesel/src/query_builder/select_statement/dsl_impls.rs

@@ -2,6 +2,7 @@ use super::BoxedSelectStatement;
 use associations::HasTable;
 use backend::Backend;
 use dsl::AsExprOf;
+use expression::nullable::Nullable;
 use expression::*;
 use insertable::Insertable;
 use query_builder::distinct_clause::*;
@@ -19,7 +20,8 @@ use query_dsl::boxed_dsl::BoxedDsl;
 use query_dsl::methods::*;
 use query_dsl::*;
 use query_source::joins::{Join, JoinOn, JoinTo};
-use sql_types::{BigInt, Bool};
+use query_source::QuerySource;
+use sql_types::{BigInt, Bool, NotNull};
 
 impl<F, S, D, W, O, L, Of, G, LC, Rhs, Kind, On> InternalJoinDsl<Rhs, Kind, On>
     for SelectStatement<F, S, D, W, O, L, Of, G, LC>
@@ -337,23 +339,52 @@ impl<F, S, D, W, O, L, Of, G, LC, LM, Modifier> ModifyLockDsl<Modifier>
     }
 }
 
-impl<'a, F, S, D, W, O, L, Of, G, DB> BoxedDsl<'a, DB> for SelectStatement<F, S, D, W, O, L, Of, G>
+impl<'a, F, S, D, W, O, L, Of, G, DB> BoxedDsl<'a, DB>
+    for SelectStatement<F, SelectClause<S>, D, W, O, L, Of, G>
 where
     Self: AsQuery,
     DB: Backend,
-    S: BoxSelectClause<'a, F, DB> + SelectClauseExpression<F>,
+    S: QueryFragment<DB> + SelectableExpression<F> + 'a,
     D: QueryFragment<DB> + 'a,
     W: Into<BoxedWhereClause<'a, DB>>,
     O: Into<Option<Box<QueryFragment<DB> + 'a>>>,
     L: QueryFragment<DB> + 'a,
     Of: QueryFragment<DB> + 'a,
     G: QueryFragment<DB> + 'a,
 {
-    type Output = BoxedSelectStatement<'a, S::SelectClauseSqlType, F, DB>;
+    type Output = BoxedSelectStatement<'a, S::SqlType, F, DB>;
 
     fn internal_into_boxed(self) -> Self::Output {
         BoxedSelectStatement::new(
-            self.select.box_select_clause(&self.from),
+            Box::new(self.select.0),
+            self.from,
+            Box::new(self.distinct),
+            self.where_clause.into(),
+            self.order.into(),
+            Box::new(self.limit),
+            Box::new(self.offset),
+            Box::new(self.group_by),
+        )
+    }
+}
+impl<'a, F, D, W, O, L, Of, G, DB> BoxedDsl<'a, DB>
+    for SelectStatement<F, DefaultSelectClause, D, W, O, L, Of, G>
+where
+    Self: AsQuery,
+    DB: Backend,
+    F: QuerySource,
+    F::DefaultSelection: QueryFragment<DB> + 'a,
+    D: QueryFragment<DB> + 'a,
+    W: Into<BoxedWhereClause<'a, DB>>,
+    O: Into<Option<Box<QueryFragment<DB> + 'a>>>,
+    L: QueryFragment<DB> + 'a,
+    Of: QueryFragment<DB> + 'a,
+    G: QueryFragment<DB> + 'a,
+{
+    type Output = BoxedSelectStatement<'a, <F::DefaultSelection as Expression>::SqlType, F, DB>;
+    fn internal_into_boxed(self) -> Self::Output {
+        BoxedSelectStatement::new(
+            Box::new(self.from.default_selection()),
             self.from,
             Box::new(self.distinct),
             self.where_clause.into(),
@@ -438,3 +469,51 @@ where
         InsertFromSelect::new(self)
     }
 }
+
+impl<'a, F, S, D, W, O, L, Of, G> NullableSelectDsl
+    for SelectStatement<F, SelectClause<S>, D, W, O, L, Of, G>
+where
+    SelectClause<S>: SelectClauseExpression<F>,
+    <SelectClause<S> as SelectClauseExpression<F>>::SelectClauseSqlType: NotNull,
+{
+    type Output = SelectStatement<F, SelectClause<Nullable<S>>, D, W, O, L, Of, G>;
+
+    fn nullable(self) -> Self::Output {
+        SelectStatement::new(
+            SelectClause(Nullable::new(self.select.0)),
+            self.from,
+            self.distinct,
+            self.where_clause,
+            self.order,
+            self.limit,
+            self.offset,
+            self.group_by,
+            self.locking,
+        )
+    }
+}
+
+impl<'a, F, D, W, O, L, Of, G> NullableSelectDsl
+    for SelectStatement<F, DefaultSelectClause, D, W, O, L, Of, G>
+where
+    F: QuerySource,
+    DefaultSelectClause: SelectClauseExpression<F>,
+    <DefaultSelectClause as SelectClauseExpression<F>>::SelectClauseSqlType: NotNull,
+{
+    type Output =
+        SelectStatement<F, SelectClause<Nullable<F::DefaultSelection>>, D, W, O, L, Of, G>;
+
+    fn nullable(self) -> Self::Output {
+        SelectStatement::new(
+            SelectClause(Nullable::new(self.from.default_selection())),
+            self.from,
+            self.distinct,
+            self.where_clause,
+            self.order,
+            self.limit,
+            self.offset,
+            self.group_by,
+            self.locking,
+        )
+    }
+}

diesel/src/query_builder/select_statement/mod.rs

@@ -26,14 +26,12 @@ use super::select_clause::*;
 use super::where_clause::*;
 use super::{AstPass, Query, QueryFragment};
 use backend::Backend;
-use expression::nullable::Nullable;
 use expression::subselect::ValidSubselect;
 use expression::*;
 use query_builder::SelectQuery;
 use query_source::joins::{AppendSelection, Inner, Join};
 use query_source::*;
 use result::QueryResult;
-use sql_types::NotNull;
 
 #[derive(Debug, Clone, Copy, QueryId)]
 #[doc(hidden)]
@@ -103,26 +101,6 @@ impl<F> SelectStatement<F> {
     }
 }
 
-impl<F, S, D, W, O, L, Of, G, LC> SelectStatement<F, S, D, W, O, L, Of, G, LC>
-where
-    S: SelectClauseExpression<F>,
-    S::SelectClauseSqlType: NotNull,
-{
-    pub fn nullable(self) -> SelectStatement<F, Nullable<S>, D, W, O, L, Of, G, LC> {
-        SelectStatement {
-            select: Nullable::new(self.select),
-            from: self.from,
-            distinct: self.distinct,
-            where_clause: self.where_clause,
-            order: self.order,
-            limit: self.limit,
-            offset: self.offset,
-            group_by: self.group_by,
-            locking: self.locking,
-        }
-    }
-}
-
 impl<F, S, D, W, O, L, Of, G, LC> Query for SelectStatement<F, S, D, W, O, L, Of, G, LC>
 where
     S: SelectClauseExpression<F>,

diesel/src/query_dsl/mod.rs

@@ -35,6 +35,7 @@ pub mod limit_dsl;
 #[doc(hidden)]
 pub mod load_dsl;
 mod locking_dsl;
+mod nullable_select_dsl;
 mod offset_dsl;
 mod order_dsl;
 mod save_changes_dsl;
@@ -67,6 +68,7 @@ pub mod methods {
     #[allow(deprecated)]
     pub use super::locking_dsl::ForUpdateDsl;
     pub use super::locking_dsl::{LockingDsl, ModifyLockDsl};
+    pub use super::nullable_select_dsl::NullableSelectDsl;
     pub use super::offset_dsl::OffsetDsl;
     pub use super::order_dsl::{OrderDsl, ThenOrderDsl};
     pub use super::select_dsl::SelectDsl;
@@ -1045,6 +1047,45 @@ pub trait QueryDsl: Sized {
     {
         methods::SingleValueDsl::single_value(self)
     }
+
+    /// Coerce the SQL type of the select clause to it's nullable equivalent.
+    ///
+    /// This is use full for writing queries that contain subselects on non null
+    /// fields comparing them to nullable fields.
+    /// ```rust
+    /// # #[macro_use] extern crate diesel;
+    /// # include!("../doctest_setup.rs");
+    /// #
+    /// # fn main() {
+    /// #    run_test();
+    /// # }
+    /// #
+    /// # fn run_test() -> QueryResult<()> {
+    /// table! {
+    ///     users {
+    ///         id -> Integer,
+    ///         name -> Text,
+    ///     }
+    /// }
+    ///
+    /// table! {
+    ///     posts {
+    ///         id -> Integer,
+    ///         by_user -> Nullable<Text>,
+    ///     }
+    /// }
+    ///
+    /// # let _: Vec<(i32, Option<String>)> =
+    /// posts::table.filter(
+    ///    posts::by_user.eq_any(users::table.select(users::name).nullable())
+    /// ).load(&connection)?;
+    /// # }
+    fn nullable(self) -> NullableSelect<Self>
+    where
+        Self: methods::NullableSelectDsl,
+    {
+        methods::NullableSelectDsl::nullable(self)
+    }
 }
 
 impl<T: Table> QueryDsl for T {}