diff --git a/diesel/src/expression/count.rs b/diesel/src/expression/count.rs
index a941b7cd7894..6502340fc677 100644
--- a/diesel/src/expression/count.rs
+++ b/diesel/src/expression/count.rs
@@ -3,7 +3,7 @@ use super::{Expression, ValidGrouping};
 use crate::backend::Backend;
 use crate::query_builder::*;
 use crate::result::QueryResult;
-use crate::sql_types::{BigInt, DieselNumericOps, Nullable, SingleValue, SqlType};
+use crate::sql_types::{BigInt, DieselNumericOps, SingleValue, SqlType};
 
 sql_function! {
     /// Creates a SQL `COUNT` expression
@@ -25,7 +25,7 @@ sql_function! {
     /// # }
     /// ```
     #[aggregate]
-    fn count<T: SqlType + SingleValue>(expr: Nullable<T>) -> BigInt;
+    fn count<T: SqlType + SingleValue>(expr: T) -> BigInt;
 }
 
 /// Creates a SQL `COUNT(*)` expression
diff --git a/diesel/src/expression/functions/aggregate_folding.rs b/diesel/src/expression/functions/aggregate_folding.rs
index 1896e21fec8a..b544c39f1dd7 100644
--- a/diesel/src/expression/functions/aggregate_folding.rs
+++ b/diesel/src/expression/functions/aggregate_folding.rs
@@ -1,5 +1,5 @@
 use crate::expression::functions::sql_function;
-use crate::sql_types::{Foldable, Nullable};
+use crate::sql_types::Foldable;
 
 sql_function! {
     /// Represents a SQL `SUM` function. This function can only take types which are
@@ -18,7 +18,7 @@ sql_function! {
     /// # }
     /// ```
     #[aggregate]
-    fn sum<ST: Foldable>(expr: Nullable<ST>) -> ST::Sum;
+    fn sum<ST: Foldable>(expr: ST) -> ST::Sum;
 }
 
 sql_function! {
@@ -64,5 +64,5 @@ sql_function! {
     /// #     Ok(())
     /// # }
     #[aggregate]
-    fn avg<ST: Foldable>(expr: Nullable<ST>) -> ST::Avg;
+    fn avg<ST: Foldable>(expr: ST) -> ST::Avg;
 }
diff --git a/diesel/src/expression/functions/aggregate_ordering.rs b/diesel/src/expression/functions/aggregate_ordering.rs
index 4b398ce09146..bb2889590a94 100644
--- a/diesel/src/expression/functions/aggregate_ordering.rs
+++ b/diesel/src/expression/functions/aggregate_ordering.rs
@@ -1,16 +1,16 @@
 use crate::expression::functions::sql_function;
-use crate::sql_types::{IntoNullable, Nullable, SingleValue, SqlOrd, SqlType};
+use crate::sql_types::{IntoNullable, SingleValue, SqlOrd, SqlType};
 
 pub trait SqlOrdAggregate: SingleValue {
     type Ret: SqlType + SingleValue;
 }
 
-impl<ST> SqlOrdAggregate for ST
+impl<T> SqlOrdAggregate for T
 where
-    ST: SqlOrd + SingleValue + IntoNullable,
-    ST::Nullable: SingleValue,
+    T: SqlOrd + IntoNullable + SingleValue,
+    T::Nullable: SqlType + SingleValue,
 {
-    type Ret = <Self as IntoNullable>::Nullable;
+    type Ret = T::Nullable;
 }
 
 sql_function! {
@@ -29,7 +29,7 @@ sql_function! {
     /// assert_eq!(Ok(Some(8)), animals.select(max(legs)).first(&connection));
     /// # }
     #[aggregate]
-    fn max<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+    fn max<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
 }
 
 sql_function! {
@@ -48,5 +48,5 @@ sql_function! {
     /// assert_eq!(Ok(Some(4)), animals.select(min(legs)).first(&connection));
     /// # }
     #[aggregate]
-    fn min<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+    fn min<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
 }
diff --git a/diesel/src/expression/functions/date_and_time.rs b/diesel/src/expression/functions/date_and_time.rs
index d6cef53d23cb..51d44189ab72 100644
--- a/diesel/src/expression/functions/date_and_time.rs
+++ b/diesel/src/expression/functions/date_and_time.rs
@@ -1,8 +1,7 @@
 use crate::backend::Backend;
+use crate::expression::coerce::Coerce;
 use crate::expression::functions::sql_function;
-#[cfg(feature = "postgres")]
-use crate::expression::{coerce::Coerce, AsExpression};
-use crate::expression::{Expression, ValidGrouping};
+use crate::expression::{AsExpression, Expression, ValidGrouping};
 use crate::query_builder::*;
 use crate::result::QueryResult;
 use crate::sql_types::*;
@@ -47,6 +46,14 @@ sql_function! {
     fn date(expr: Timestamp) -> Date;
 }
 
+impl AsExpression<Nullable<Timestamp>> for now {
+    type Expression = Coerce<now, Nullable<Timestamp>>;
+
+    fn as_expression(self) -> Self::Expression {
+        Coerce::new(self)
+    }
+}
+
 #[cfg(feature = "postgres")]
 impl AsExpression<Timestamptz> for now {
     type Expression = Coerce<now, Timestamptz>;
@@ -85,3 +92,11 @@ impl_selectable_expression!(today);
 
 operator_allowed!(today, Add, add);
 operator_allowed!(today, Sub, sub);
+
+impl AsExpression<Nullable<Date>> for today {
+    type Expression = Coerce<today, Nullable<Date>>;
+
+    fn as_expression(self) -> Self::Expression {
+        Coerce::new(self)
+    }
+}
diff --git a/diesel/src/expression/functions/helper_types.rs b/diesel/src/expression/functions/helper_types.rs
index 0ccf8e53065a..f99a0510ef63 100644
--- a/diesel/src/expression/functions/helper_types.rs
+++ b/diesel/src/expression/functions/helper_types.rs
@@ -1,12 +1,11 @@
 #![allow(non_camel_case_types)]
 
-use crate::dsl::{AsExprOf, SqlTypeOf};
+use crate::dsl::SqlTypeOf;
 use crate::expression::grouped::Grouped;
 use crate::expression::operators;
-use crate::sql_types::{Bool, Nullable};
 
 /// The return type of [`not(expr)`](../dsl/fn.not.html)
-pub type not<Expr> = operators::Not<Grouped<AsExprOf<Expr, Nullable<Bool>>>>;
+pub type not<Expr> = operators::Not<Grouped<Expr>>;
 
 /// The return type of [`max(expr)`](../dsl/fn.max.html)
 pub type max<Expr> = super::aggregate_ordering::max::HelperType<SqlTypeOf<Expr>, Expr>;
diff --git a/diesel/src/expression/helper_types.rs b/diesel/src/expression/helper_types.rs
index 3b3e8e5576c1..23faff7534fb 100644
--- a/diesel/src/expression/helper_types.rs
+++ b/diesel/src/expression/helper_types.rs
@@ -89,11 +89,12 @@ pub type Nullable<Expr> = super::nullable::Nullable<Expr>;
 
 /// The return type of
 /// [`lhs.and(rhs)`](../expression_methods/trait.BoolExpressionMethods.html#method.and)
-pub type And<Lhs, Rhs> = Grouped<super::operators::And<Nullable<Lhs>, AsExpr<Rhs, Nullable<Lhs>>>>;
+pub type And<Lhs, Rhs, ST = sql_types::Bool> =
+    Grouped<super::operators::And<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.or(rhs)`](../expression_methods/trait.BoolExpressionMethods.html#method.or)
-pub type Or<Lhs, Rhs> = Grouped<super::operators::Or<Lhs, AsExpr<Rhs, Nullable<Lhs>>>>;
+pub type Or<Lhs, Rhs, ST = sql_types::Bool> = Grouped<super::operators::Or<Lhs, AsExprOf<Rhs, ST>>>;
 
 /// The return type of
 /// [`lhs.escape('x')`](../expression_methods/trait.EscapeExpressionMethods.html#method.escape)
diff --git a/diesel/src/expression/mod.rs b/diesel/src/expression/mod.rs
index f258f92f473c..f91daac169cf 100644
--- a/diesel/src/expression/mod.rs
+++ b/diesel/src/expression/mod.rs
@@ -82,7 +82,7 @@ pub use self::sql_literal::{SqlLiteral, UncheckedBind};
 
 use crate::backend::Backend;
 use crate::dsl::AsExprOf;
-use crate::sql_types::{HasSqlType, IntoNotNullable, SingleValue, SqlType};
+use crate::sql_types::{HasSqlType, SingleValue, SqlType};
 
 /// Represents a typed fragment of SQL.
 ///
@@ -208,101 +208,14 @@ pub use diesel_derives::AsExpression;
 
 impl<T, ST> AsExpression<ST> for T
 where
-    ST: SqlType + IntoNotNullable + TypedExpressionType,
-    ST::NotNullable: SingleValue,
-    self::as_expression_impl::ExpressionImplHelper<T, ST::IsNull, <T::SqlType as SqlType>::IsNull>:
-        self::as_expression_impl::AsExpressionHelper<ST>,
-    T: Expression,
-    T::SqlType: SqlType,
+    T: Expression<SqlType = ST>,
+    ST: SqlType + TypedExpressionType,
 {
-    type Expression = <self::as_expression_impl::ExpressionImplHelper<
-        T,
-        ST::IsNull,
-        <T::SqlType as SqlType>::IsNull,
-    > as self::as_expression_impl::AsExpressionHelper<ST>>::Expression;
-
-    fn as_expression(self) -> Self::Expression {
-        use self::as_expression_impl::AsExpressionHelper;
-
-        let t = self::as_expression_impl::ExpressionImplHelper::<
-            _,
-            ST::IsNull,
-            <T::SqlType as SqlType>::IsNull,
-        >(self, std::marker::PhantomData);
-        t.as_expression()
-    }
-}
-
-mod as_expression_impl {
-    use super::*;
-    use crate::sql_types::is_nullable;
+    type Expression = Self;
 
-    #[allow(missing_debug_implementations)]
-    pub struct ExpressionImplHelper<T, IsNullExpr, IsNullAsExpr>(
-        pub T,
-        pub std::marker::PhantomData<(IsNullExpr, IsNullAsExpr)>,
-    );
-
-    // We could use `AsExpression` here instead of defining a new trait in theory
-    // in practice we hit https://github.com/rust-lang/rust/issues/77446 then
-    // when defining a custom type in a third party crate
-    pub trait AsExpressionHelper<ST: TypedExpressionType> {
-        type Expression: Expression<SqlType = ST>;
-
-        fn as_expression(self) -> Self::Expression;
+    fn as_expression(self) -> Self {
+        self
     }
-
-    // This impl is for accepting a not nullable expression in a position where
-    // a not nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::NotNull, is_nullable::NotNull>
-    where
-        ST: SqlType<IsNull = is_nullable::NotNull> + TypedExpressionType,
-        T: Expression<SqlType = ST>,
-    {
-        type Expression = T;
-
-        fn as_expression(self) -> Self::Expression {
-            self.0
-        }
-    }
-
-    // This impl is for accepting a not nullable expression in a position where
-    // a nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::IsNullable, is_nullable::NotNull>
-    where
-        ST: SqlType<IsNull = is_nullable::IsNullable> + IntoNotNullable + TypedExpressionType,
-        ST::NotNullable: TypedExpressionType + SqlType,
-        T: Expression<SqlType = ST::NotNullable>,
-        super::nullable::Nullable<T>: Expression<SqlType = ST>,
-    {
-        type Expression = super::nullable::Nullable<T>;
-
-        fn as_expression(self) -> Self::Expression {
-            super::nullable::Nullable::new(self.0)
-        }
-    }
-
-    // This impl is for accepting a nullable expression in a position where
-    // a nullable expression is expected
-    impl<T, ST> AsExpressionHelper<ST>
-        for ExpressionImplHelper<T, is_nullable::IsNullable, is_nullable::IsNullable>
-    where
-        ST: SqlType<IsNull = is_nullable::IsNullable> + TypedExpressionType,
-        T: Expression<SqlType = ST>,
-    {
-        type Expression = T;
-
-        fn as_expression(self) -> Self::Expression {
-            self.0
-        }
-    }
-
-    // impl<T, ST> AsExpressionHelper<ST> for
-    //     ExpressionImplHelper<T, is_nullable::NotNull, is_nullable::IsNullable>
-    // is missing because we don't want to accept a nullable expression in possition where
-    // where a not nullable expression is expected
 }
 
 /// Converts a type to its representation for use in Diesel's query builder.
diff --git a/diesel/src/expression/not.rs b/diesel/src/expression/not.rs
index 96b7916c3e37..e9fb4003cd59 100644
--- a/diesel/src/expression/not.rs
+++ b/diesel/src/expression/not.rs
@@ -1,7 +1,7 @@
 use crate::expression::grouped::Grouped;
-use crate::expression::AsExpression;
+use crate::expression::Expression;
 use crate::helper_types::not;
-use crate::sql_types::{Bool, Nullable};
+use crate::sql_types::BoolOrNullableBool;
 
 /// Creates a SQL `NOT` expression
 ///
@@ -25,7 +25,8 @@ use crate::sql_types::{Bool, Nullable};
 /// ```
 pub fn not<T>(expr: T) -> not<T>
 where
-    T: AsExpression<Nullable<Bool>>,
+    T: Expression,
+    <T as Expression>::SqlType: BoolOrNullableBool,
 {
-    super::operators::Not::new(Grouped(expr.as_expression()))
+    super::operators::Not::new(Grouped(expr))
 }
diff --git a/diesel/src/expression/operators.rs b/diesel/src/expression/operators.rs
index 93aff0c667d5..acc17ea2c18c 100644
--- a/diesel/src/expression/operators.rs
+++ b/diesel/src/expression/operators.rs
@@ -436,11 +436,26 @@ macro_rules! prefix_operator {
             notation = prefix,
             struct_name = $name,
             operator = $operator,
-            return_ty = ($return_ty),
+            return_ty = (
+                $crate::sql_types::is_nullable::MaybeNullable<
+                    $crate::sql_types::is_nullable::IsSqlTypeNullable<
+                        <Expr as $crate::expression::Expression>::SqlType
+                    >,
+                    $return_ty,
+                >
+            ),
             ty_params = (Expr,),
             field_names = (expr,),
             backend_ty_params = (DB,),
             backend_ty = DB,
+            expression_ty_params = (),
+            expression_bounds = (
+                Expr: $crate::expression::Expression,
+                <Expr as $crate::expression::Expression>::SqlType: $crate::sql_types::SqlType,
+                $crate::sql_types::is_nullable::IsSqlTypeNullable<
+                    <Expr as $crate::expression::Expression>::SqlType
+                >: $crate::sql_types::MaybeNullableType<$return_ty>,
+            ),
         );
     };
 
@@ -449,11 +464,26 @@ macro_rules! prefix_operator {
             notation = prefix,
             struct_name = $name,
             operator = $operator,
-            return_ty = ($return_ty),
+            return_ty = (
+                $crate::sql_types::is_nullable::MaybeNullable<
+                    $crate::sql_types::is_nullable::IsSqlTypeNullable<
+                        <Expr as $crate::expression::Expression>::SqlType
+                    >,
+                    $return_ty,
+                >
+            ),
             ty_params = (Expr,),
             field_names = (expr,),
             backend_ty_params = (),
             backend_ty = $backend,
+            expression_ty_params = (),
+            expression_bounds = (
+                Expr: $crate::expression::Expression,
+                <Expr as $crate::expression::Expression>::SqlType: $crate::sql_types::SqlType,
+                $crate::sql_types::is_nullable::IsSqlTypeNullable<
+                    <Expr as $crate::expression::Expression>::SqlType
+                >: $crate::sql_types::MaybeNullableType<$return_ty>,
+            ),
         );
     };
 }
@@ -495,11 +525,7 @@ postfix_operator!(
     crate::expression::expression_types::NotSelectable
 );
 
-prefix_operator!(
-    Not,
-    " NOT ",
-    crate::sql_types::Nullable<crate::sql_types::Bool>
-);
+prefix_operator!(Not, " NOT ");
 
 use crate::backend::Backend;
 use crate::expression::{TypedExpressionType, ValidGrouping};
diff --git a/diesel/src/expression_methods/bool_expression_methods.rs b/diesel/src/expression_methods/bool_expression_methods.rs
index 9db25db86b53..c31a59f62faa 100644
--- a/diesel/src/expression_methods/bool_expression_methods.rs
+++ b/diesel/src/expression_methods/bool_expression_methods.rs
@@ -1,8 +1,8 @@
 use crate::dsl;
 use crate::expression::grouped::Grouped;
 use crate::expression::operators::{And, Or};
-use crate::expression::{AsExpression, Expression};
-use crate::sql_types::{BoolOrNullableBool, IntoNullable, SingleValue, SqlType};
+use crate::expression::{AsExpression, Expression, TypedExpressionType};
+use crate::sql_types::{BoolOrNullableBool, SqlType};
 
 /// Methods present on boolean expressions
 pub trait BoolExpressionMethods: Expression + Sized {
@@ -37,17 +37,15 @@ pub trait BoolExpressionMethods: Expression + Sized {
     /// assert_eq!(expected, data);
     /// #     Ok(())
     /// # }
-    fn and<T>(self, other: T) -> dsl::And<Self, T>
+    /// ```
+    fn and<T, ST>(self, other: T) -> dsl::And<Self, T, ST>
     where
-        Self::SqlType: SqlType + IntoNullable,
-        <Self::SqlType as IntoNullable>::Nullable: SingleValue,
-        T: AsExpression<<Self::SqlType as IntoNullable>::Nullable>,
+        Self::SqlType: SqlType,
+        ST: SqlType + TypedExpressionType,
+        T: AsExpression<ST>,
         And<Self, T::Expression>: Expression,
     {
-        Grouped(And::new(
-            crate::expression::nullable::Nullable::new(self),
-            other.as_expression(),
-        ))
+        Grouped(And::new(self, other.as_expression()))
     }
 
     /// Creates a SQL `OR` expression
@@ -87,11 +85,12 @@ pub trait BoolExpressionMethods: Expression + Sized {
     /// assert_eq!(expected, data);
     /// #     Ok(())
     /// # }
-    fn or<T>(self, other: T) -> dsl::Or<Self, T>
+    /// ```
+    fn or<T, ST>(self, other: T) -> dsl::Or<Self, T, ST>
     where
-        Self::SqlType: SqlType + IntoNullable,
-        <Self::SqlType as IntoNullable>::Nullable: SingleValue,
-        T: AsExpression<<Self::SqlType as IntoNullable>::Nullable>,
+        Self::SqlType: SqlType,
+        ST: SqlType + TypedExpressionType,
+        T: AsExpression<ST>,
         Or<Self, T::Expression>: Expression,
     {
         Grouped(Or::new(self, other.as_expression()))
diff --git a/diesel/src/expression_methods/eq_all.rs b/diesel/src/expression_methods/eq_all.rs
index 9efce1faab88..f0505cdfebd9 100644
--- a/diesel/src/expression_methods/eq_all.rs
+++ b/diesel/src/expression_methods/eq_all.rs
@@ -1,16 +1,15 @@
 use crate::expression::grouped::Grouped;
-use crate::expression::nullable::Nullable;
 use crate::expression::operators::And;
 use crate::expression::Expression;
 use crate::expression_methods::*;
-use crate::sql_types::{self, Bool};
+use crate::sql_types::Bool;
 
 /// This method is used by `FindDsl` to work with tuples. Because we cannot
 /// express this without specialization or overlapping impls, it is brute force
 /// implemented on columns in the `column!` macro.
 #[doc(hidden)]
 pub trait EqAll<Rhs> {
-    type Output: Expression<SqlType = sql_types::Nullable<Bool>>;
+    type Output: Expression<SqlType = Bool>;
 
     fn eq_all(self, rhs: Rhs) -> Self::Output;
 }
@@ -29,7 +28,7 @@ macro_rules! impl_eq_all {
             ($($Left,)+): EqAll<($($Right,)+)>,
         {
             type Output = Grouped<And<
-                Nullable<<$Left1 as EqAll<$Right1>>::Output>,
+                <$Left1 as EqAll<$Right1>>::Output,
                 <($($Left,)+) as EqAll<($($Right,)+)>>::Output,
             >>;
 
diff --git a/diesel/src/macros/mod.rs b/diesel/src/macros/mod.rs
index a5e65f1cd464..73ac7474051e 100644
--- a/diesel/src/macros/mod.rs
+++ b/diesel/src/macros/mod.rs
@@ -109,16 +109,13 @@ macro_rules! __diesel_column {
 
         impl<T> $crate::EqAll<T> for $column_name where
             T: $crate::expression::AsExpression<$($Type)*>,
-            $crate::dsl::Nullable<$crate::dsl::Eq<$column_name, T::Expression>>:
-            $crate::Expression<SqlType = $crate::sql_types::Nullable<$crate::sql_types::Bool>>,
+            $crate::dsl::Eq<$column_name, T::Expression>: $crate::Expression<SqlType=$crate::sql_types::Bool>,
         {
-            type Output = $crate::dsl::Nullable<$crate::dsl::Eq<Self, T::Expression>>;
+            type Output = $crate::dsl::Eq<Self, T::Expression>;
 
             fn eq_all(self, rhs: T) -> Self::Output {
                 use $crate::expression_methods::ExpressionMethods;
-                use $crate::expression_methods::NullableExpressionMethods;
-
-                self.eq(rhs).nullable()
+                self.eq(rhs)
             }
         }
 
diff --git a/diesel/src/type_impls/option.rs b/diesel/src/type_impls/option.rs
index c49a9c94c31d..1929df7b807d 100644
--- a/diesel/src/type_impls/option.rs
+++ b/diesel/src/type_impls/option.rs
@@ -60,11 +60,12 @@ where
     }
 }
 
-impl<T, ST> AsExpression<ST> for Option<T>
+impl<T, ST> AsExpression<Nullable<ST>> for Option<T>
 where
-    ST: SqlType<IsNull = is_nullable::IsNullable> + SingleValue,
+    ST: SqlType<IsNull = is_nullable::NotNull>,
+    Nullable<ST>: TypedExpressionType,
 {
-    type Expression = Bound<ST, Self>;
+    type Expression = Bound<Nullable<ST>, Self>;
 
     fn as_expression(self) -> Self::Expression {
         Bound::new(self)
diff --git a/diesel_compile_tests/tests/fail/aggregate_expression_requires_column_from_same_table.stderr b/diesel_compile_tests/tests/fail/aggregate_expression_requires_column_from_same_table.stderr
index 889f373d9c59..7ff335a1e30e 100644
--- a/diesel_compile_tests/tests/fail/aggregate_expression_requires_column_from_same_table.stderr
+++ b/diesel_compile_tests/tests/fail/aggregate_expression_requires_column_from_same_table.stderr
@@ -10,9 +10,8 @@ error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::Join<Left, Right, diesel::query_source::joins::LeftOuter>>>
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::JoinOn<Join, On>>>
              <posts::columns::id as diesel::SelectableExpression<posts::table>>
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFromClause<posts::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:19:31
@@ -23,10 +22,9 @@ error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFrom
    = help: the following implementations were found:
              <users::table as diesel::query_source::AppearsInFromClause<users::table>>
    = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `posts::columns::id`
-   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<users::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:20:38
@@ -40,9 +38,8 @@ error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::Join<Left, Right, diesel::query_source::joins::LeftOuter>>>
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::JoinOn<Join, On>>>
              <posts::columns::id as diesel::SelectableExpression<posts::table>>
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFromClause<posts::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:20:31
@@ -53,10 +50,9 @@ error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFrom
    = help: the following implementations were found:
              <users::table as diesel::query_source::AppearsInFromClause<users::table>>
    = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `posts::columns::id`
-   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_folding::avg::avg<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<users::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:21:38
@@ -70,9 +66,8 @@ error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::Join<Left, Right, diesel::query_source::joins::LeftOuter>>>
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::JoinOn<Join, On>>>
              <posts::columns::id as diesel::SelectableExpression<posts::table>>
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFromClause<posts::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:21:31
@@ -83,10 +78,9 @@ error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFrom
    = help: the following implementations were found:
              <users::table as diesel::query_source::AppearsInFromClause<users::table>>
    = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `posts::columns::id`
-   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<users::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:22:38
@@ -100,9 +94,8 @@ error[E0277]: the trait bound `posts::columns::id: diesel::SelectableExpression<
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::Join<Left, Right, diesel::query_source::joins::LeftOuter>>>
              <posts::columns::id as diesel::SelectableExpression<diesel::query_source::joins::JoinOn<Join, On>>>
              <posts::columns::id as diesel::SelectableExpression<posts::table>>
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFromClause<posts::table>` is not satisfied
   --> $DIR/aggregate_expression_requires_column_from_same_table.rs:22:31
@@ -113,7 +106,6 @@ error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFrom
    = help: the following implementations were found:
              <users::table as diesel::query_source::AppearsInFromClause<users::table>>
    = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `posts::columns::id`
-   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::nullable::Nullable<posts::columns::id>`
-   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<posts::columns::id>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::AppearsOnTable<users::table>` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::SelectableExpression<users::table>` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, posts::columns::id>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Integer, posts::columns::id>>` for `diesel::query_builder::SelectStatement<users::table>`
diff --git a/diesel_compile_tests/tests/fail/cannot_mix_aggregate_and_non_aggregate_selects.stderr b/diesel_compile_tests/tests/fail/cannot_mix_aggregate_and_non_aggregate_selects.stderr
index f8cc62f8c12f..527a1277a6cd 100644
--- a/diesel_compile_tests/tests/fail/cannot_mix_aggregate_and_non_aggregate_selects.stderr
+++ b/diesel_compile_tests/tests/fail/cannot_mix_aggregate_and_non_aggregate_selects.stderr
@@ -19,8 +19,8 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::No: diesel::exp
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::No>>
-   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `diesel::expression::ops::Add<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, users::columns::nullable_int_col>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::ops::Add<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, users::columns::nullable_int_col>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `diesel::expression::ops::Add<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Nullable<diesel::sql_types::Integer>, users::columns::nullable_int_col>>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::ops::Add<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Nullable<diesel::sql_types::Integer>, users::columns::nullable_int_col>>>` for `diesel::query_builder::SelectStatement<users::table>`
 
 error[E0277]: the trait bound `diesel::expression::is_aggregate::No: diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Yes>` is not satisfied
   --> $DIR/cannot_mix_aggregate_and_non_aggregate_selects.rs:24:24
@@ -31,6 +31,6 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::No: diesel::exp
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::No>>
-   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `f::__Derived<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, users::columns::nullable_int_col>>`
-   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `f::f<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, users::columns::nullable_int_col>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<f::f<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Integer, users::columns::nullable_int_col>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `f::__Derived<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Nullable<diesel::sql_types::Integer>, users::columns::nullable_int_col>>`
+   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `f::f<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Nullable<diesel::sql_types::Integer>, users::columns::nullable_int_col>>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<f::f<users::columns::nullable_int_col, diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Nullable<diesel::sql_types::Integer>, users::columns::nullable_int_col>>>` for `diesel::query_builder::SelectStatement<users::table>`
diff --git a/diesel_compile_tests/tests/fail/cannot_pass_aggregate_to_where.stderr b/diesel_compile_tests/tests/fail/cannot_pass_aggregate_to_where.stderr
index 6c03f1f897bf..15a63c6a54da 100644
--- a/diesel_compile_tests/tests/fail/cannot_pass_aggregate_to_where.stderr
+++ b/diesel_compile_tests/tests/fail/cannot_pass_aggregate_to_where.stderr
@@ -7,4 +7,4 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::Yes: diesel::ex
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Yes>>
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Gt<diesel::expression::count::count::count<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<users::columns::id>>, diesel::expression::bound::Bound<diesel::sql_types::BigInt, i64>>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Gt<diesel::expression::count::count::count<diesel::sql_types::Integer, users::columns::id>, diesel::expression::bound::Bound<diesel::sql_types::BigInt, i64>>>>` for `diesel::query_builder::SelectStatement<users::table>`
diff --git a/diesel_compile_tests/tests/fail/custom_returning_requires_nonaggregate.stderr b/diesel_compile_tests/tests/fail/custom_returning_requires_nonaggregate.stderr
index 2bb502c79f78..ccad0a854542 100644
--- a/diesel_compile_tests/tests/fail/custom_returning_requires_nonaggregate.stderr
+++ b/diesel_compile_tests/tests/fail/custom_returning_requires_nonaggregate.stderr
@@ -7,7 +7,7 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::Yes: diesel::ex
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Yes>>
-   = note: required because of the requirements on the impl of `diesel::query_builder::Query` for `diesel::query_builder::UpdateStatement<users::table, diesel::query_builder::where_clause::WhereClause<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<users::columns::id, diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>>>>, diesel::query_builder::update_statement::changeset::Assign<users::columns::name, diesel::expression::bound::Bound<diesel::sql_types::Text, &str>>, diesel::query_builder::returning_clause::ReturningClause<diesel::expression::count::count::count<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<users::columns::id>>>>`
+   = note: required because of the requirements on the impl of `diesel::query_builder::Query` for `diesel::query_builder::UpdateStatement<users::table, diesel::query_builder::where_clause::WhereClause<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<users::columns::id, diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>>>>, diesel::query_builder::update_statement::changeset::Assign<users::columns::name, diesel::expression::bound::Bound<diesel::sql_types::Text, &str>>, diesel::query_builder::returning_clause::ReturningClause<diesel::expression::count::count::count<diesel::sql_types::Integer, users::columns::id>>>`
 
 error[E0277]: the trait bound `diesel::expression::is_aggregate::No: diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Yes>` is not satisfied
   --> $DIR/custom_returning_requires_nonaggregate.rs:27:53
@@ -18,5 +18,5 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::No: diesel::exp
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::No as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::No>>
-   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `(users::columns::name, diesel::expression::count::count::count<diesel::sql_types::Text, diesel::expression::nullable::Nullable<users::columns::name>>)`
-   = note: required because of the requirements on the impl of `diesel::query_builder::Query` for `diesel::query_builder::InsertStatement<users::table, diesel::query_builder::ValuesClause<(diesel::insertable::ColumnInsertValue<users::columns::name, diesel::expression::bound::Bound<diesel::sql_types::Text, &std::string::String>>,), users::table>, diesel::query_builder::insert_statement::Insert, diesel::query_builder::returning_clause::ReturningClause<(users::columns::name, diesel::expression::count::count::count<diesel::sql_types::Text, diesel::expression::nullable::Nullable<users::columns::name>>)>>`
+   = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `(users::columns::name, diesel::expression::count::count::count<diesel::sql_types::Text, users::columns::name>)`
+   = note: required because of the requirements on the impl of `diesel::query_builder::Query` for `diesel::query_builder::InsertStatement<users::table, diesel::query_builder::ValuesClause<(diesel::insertable::ColumnInsertValue<users::columns::name, diesel::expression::bound::Bound<diesel::sql_types::Text, &std::string::String>>,), users::table>, diesel::query_builder::insert_statement::Insert, diesel::query_builder::returning_clause::ReturningClause<(users::columns::name, diesel::expression::count::count::count<diesel::sql_types::Text, users::columns::name>)>>`
diff --git a/diesel_compile_tests/tests/fail/expressions_can_only_be_compared_for_equality_to_expressions_of_same_type.stderr b/diesel_compile_tests/tests/fail/expressions_can_only_be_compared_for_equality_to_expressions_of_same_type.stderr
index e7bd2a4d7dd1..8df0e77bd858 100644
--- a/diesel_compile_tests/tests/fail/expressions_can_only_be_compared_for_equality_to_expressions_of_same_type.stderr
+++ b/diesel_compile_tests/tests/fail/expressions_can_only_be_compared_for_equality_to_expressions_of_same_type.stderr
@@ -13,4 +13,4 @@ error[E0271]: type mismatch resolving `<users::columns::name as diesel::Expressi
 16 |     let pred = id.eq(name);
    |                   ^^ expected struct `diesel::sql_types::Text`, found struct `diesel::sql_types::Integer`
    |
-   = note: required because of the requirements on the impl of `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Integer>` for `diesel::expression::as_expression_impl::ExpressionImplHelper<users::columns::name, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull>`
+   = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Integer>` for `users::columns::name`
diff --git a/diesel_compile_tests/tests/fail/filter_requires_bool_nonaggregate_expression.stderr b/diesel_compile_tests/tests/fail/filter_requires_bool_nonaggregate_expression.stderr
index e9344f0609f9..5a00a16beedb 100644
--- a/diesel_compile_tests/tests/fail/filter_requires_bool_nonaggregate_expression.stderr
+++ b/diesel_compile_tests/tests/fail/filter_requires_bool_nonaggregate_expression.stderr
@@ -15,4 +15,4 @@ error[E0277]: the trait bound `diesel::expression::is_aggregate::Yes: diesel::ex
    = help: the following implementations were found:
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Never>>
              <diesel::expression::is_aggregate::Yes as diesel::expression::MixedAggregates<diesel::expression::is_aggregate::Yes>>
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, diesel::expression::nullable::Nullable<users::columns::id>>, diesel::expression::bound::Bound<diesel::sql_types::Nullable<diesel::sql_types::BigInt>, i64>>>>` for `diesel::query_builder::SelectStatement<users::table>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::functions::aggregate_folding::sum::sum<diesel::sql_types::Integer, users::columns::id>, diesel::expression::bound::Bound<diesel::sql_types::Nullable<diesel::sql_types::BigInt>, i64>>>>` for `diesel::query_builder::SelectStatement<users::table>`
diff --git a/diesel_compile_tests/tests/fail/find_requires_correct_type.stderr b/diesel_compile_tests/tests/fail/find_requires_correct_type.stderr
index 3fcdab585f20..de19fed7d95e 100644
--- a/diesel_compile_tests/tests/fail/find_requires_correct_type.stderr
+++ b/diesel_compile_tests/tests/fail/find_requires_correct_type.stderr
@@ -5,9 +5,8 @@ error[E0277]: the trait bound `str: diesel::Expression` is not satisfied
    |                                 ^^^ the trait `diesel::Expression` is not implemented for `str`
    |
    = note: required because of the requirements on the impl of `diesel::Expression` for `&str`
-   = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Integer>` for `&str`
-   = note: required because of the requirements on the impl of `diesel::EqAll<&str>` for `int_primary_key::columns::id`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FindDsl<&str>` for `int_primary_key::table`
+   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::operators::Eq<int_primary_key::columns::id, &str>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<int_primary_key::columns::id, &str>>>` for `diesel::query_builder::SelectStatement<int_primary_key::table>`
 
 error[E0277]: the trait bound `str: diesel::expression::ValidGrouping<()>` is not satisfied
   --> $DIR/find_requires_correct_type.rs:20:33
@@ -17,7 +16,7 @@ error[E0277]: the trait bound `str: diesel::expression::ValidGrouping<()>` is no
    |
    = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `&str`
    = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `diesel::expression::operators::Eq<int_primary_key::columns::id, &str>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::nullable::Nullable<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<int_primary_key::columns::id, &str>>>>` for `diesel::query_builder::SelectStatement<int_primary_key::table>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<int_primary_key::columns::id, &str>>>` for `diesel::query_builder::SelectStatement<int_primary_key::table>`
 
 error[E0277]: the trait bound `{integer}: diesel::Expression` is not satisfied
   --> $DIR/find_requires_correct_type.rs:22:36
@@ -32,8 +31,7 @@ error[E0277]: the trait bound `{integer}: diesel::Expression` is not satisfied
              <(A, B, C, D) as diesel::Expression>
            and 100 others
    = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>`
-   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::nullable::Nullable<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::nullable::Nullable<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>>>>` for `diesel::query_builder::SelectStatement<string_primary_key::table>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>>>` for `diesel::query_builder::SelectStatement<string_primary_key::table>`
 
 error[E0277]: the trait bound `{integer}: diesel::expression::ValidGrouping<()>` is not satisfied
   --> $DIR/find_requires_correct_type.rs:22:36
@@ -48,4 +46,4 @@ error[E0277]: the trait bound `{integer}: diesel::expression::ValidGrouping<()>`
              <(A, B, C, D) as diesel::expression::ValidGrouping<__GroupByClause>>
            and 117 others
    = note: required because of the requirements on the impl of `diesel::expression::ValidGrouping<()>` for `diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::nullable::Nullable<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>>>>` for `diesel::query_builder::SelectStatement<string_primary_key::table>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::filter_dsl::FilterDsl<diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<string_primary_key::columns::id, {integer}>>>` for `diesel::query_builder::SelectStatement<string_primary_key::table>`
diff --git a/diesel_compile_tests/tests/fail/ordering_functions_require_ord.stderr b/diesel_compile_tests/tests/fail/ordering_functions_require_ord.stderr
index e1cce2e47658..4eed0f326e47 100644
--- a/diesel_compile_tests/tests/fail/ordering_functions_require_ord.stderr
+++ b/diesel_compile_tests/tests/fail/ordering_functions_require_ord.stderr
@@ -6,7 +6,7 @@ error[E0277]: the trait bound `diesel::sql_types::Bool: diesel::sql_types::SqlOr
    |
   ::: $WORKSPACE/diesel/src/expression/functions/aggregate_ordering.rs
    |
-   |     fn max<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+   |     fn max<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
    |                --------------- required by this bound in `diesel::dsl::max`
    |
    = note: required because of the requirements on the impl of `diesel::dsl::SqlOrdAggregate` for `diesel::sql_types::Bool`
@@ -18,8 +18,8 @@ error[E0277]: the trait bound `diesel::sql_types::Bool: diesel::sql_types::SqlOr
    |                                      ^^^^^^^^^^^^^ the trait `diesel::sql_types::SqlOrd` is not implemented for `diesel::sql_types::Bool`
    |
    = note: required because of the requirements on the impl of `diesel::dsl::SqlOrdAggregate` for `diesel::sql_types::Bool`
-   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Bool, diesel::expression::nullable::Nullable<stuff::columns::b>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Bool, diesel::expression::nullable::Nullable<stuff::columns::b>>>` for `stuff::table`
+   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Bool, stuff::columns::b>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::max::max<diesel::sql_types::Bool, stuff::columns::b>>` for `stuff::table`
 
 error[E0277]: the trait bound `diesel::sql_types::Bool: diesel::sql_types::SqlOrd` is not satisfied
   --> $DIR/ordering_functions_require_ord.rs:14:38
@@ -29,7 +29,7 @@ error[E0277]: the trait bound `diesel::sql_types::Bool: diesel::sql_types::SqlOr
    |
   ::: $WORKSPACE/diesel/src/expression/functions/aggregate_ordering.rs
    |
-   |     fn min<ST: SqlOrdAggregate>(expr: Nullable<ST>) -> ST::Ret;
+   |     fn min<ST: SqlOrdAggregate>(expr: ST) -> ST::Ret;
    |                --------------- required by this bound in `diesel::dsl::min`
    |
    = note: required because of the requirements on the impl of `diesel::dsl::SqlOrdAggregate` for `diesel::sql_types::Bool`
@@ -41,5 +41,5 @@ error[E0277]: the trait bound `diesel::sql_types::Bool: diesel::sql_types::SqlOr
    |                                      ^^^^^^^^^^^^^ the trait `diesel::sql_types::SqlOrd` is not implemented for `diesel::sql_types::Bool`
    |
    = note: required because of the requirements on the impl of `diesel::dsl::SqlOrdAggregate` for `diesel::sql_types::Bool`
-   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Bool, diesel::expression::nullable::Nullable<stuff::columns::b>>`
-   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Bool, diesel::expression::nullable::Nullable<stuff::columns::b>>>` for `stuff::table`
+   = note: required because of the requirements on the impl of `diesel::Expression` for `diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Bool, stuff::columns::b>`
+   = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<diesel::expression::functions::aggregate_ordering::min::min<diesel::sql_types::Bool, stuff::columns::b>>` for `stuff::table`
diff --git a/diesel_compile_tests/tests/fail/pg_upsert_do_update_requires_valid_update.stderr b/diesel_compile_tests/tests/fail/pg_upsert_do_update_requires_valid_update.stderr
index ff106c0d9f1f..c166493c3fb3 100644
--- a/diesel_compile_tests/tests/fail/pg_upsert_do_update_requires_valid_update.stderr
+++ b/diesel_compile_tests/tests/fail/pg_upsert_do_update_requires_valid_update.stderr
@@ -51,4 +51,4 @@ error[E0271]: type mismatch resolving `<diesel::query_builder::upsert::on_confli
 66 |         .set(name.eq(excluded(id)));
    |                   ^^ expected struct `diesel::sql_types::Integer`, found struct `diesel::sql_types::Text`
    |
-   = note: required because of the requirements on the impl of `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::query_builder::upsert::on_conflict_actions::Excluded<users::columns::id>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull>`
+   = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::query_builder::upsert::on_conflict_actions::Excluded<users::columns::id>`
diff --git a/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.rs b/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.rs
index 247570538bbe..b3f110fc8e58 100644
--- a/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.rs
+++ b/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.rs
@@ -1,7 +1,7 @@
 extern crate diesel;
 
-use diesel::*;
 use diesel::sql_types::Text;
+use diesel::*;
 
 table! {
     users {
@@ -31,8 +31,7 @@ joinable!(pets -> users (user_id));
 allow_tables_to_appear_in_same_query!(posts, users, pets);
 sql_function!(fn lower(x: Text) -> Text);
 
-fn main() {
-}
+fn main() {}
 
 fn direct_joins() {
     let join = users::table.left_outer_join(posts::table);
@@ -50,8 +49,9 @@ fn direct_joins() {
 }
 
 fn nested_outer_joins_left_associative() {
-
-    let join = users::table.left_outer_join(posts::table).left_outer_join(pets::table);
+    let join = users::table
+        .left_outer_join(posts::table)
+        .left_outer_join(pets::table);
 
     // Invalid, only Nullable<title> is selectable
     let _ = join.select(posts::title);
@@ -66,7 +66,9 @@ fn nested_outer_joins_left_associative() {
 }
 
 fn nested_mixed_joins_left_associative() {
-    let join = users::table.left_outer_join(posts::table).inner_join(pets::table);
+    let join = users::table
+        .left_outer_join(posts::table)
+        .inner_join(pets::table);
 
     // Invalid, only Nullable<title> is selectable
     let _ = join.select(posts::title);
diff --git a/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.stderr b/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.stderr
index 4536e2ce7965..c83425ec4cf6 100644
--- a/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.stderr
+++ b/diesel_compile_tests/tests/fail/right_side_of_left_join_requires_nullable.stderr
@@ -1,7 +1,7 @@
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:41:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:40:18
    |
-41 |     let _ = join.select(posts::title);
+40 |     let _ = join.select(posts::title);
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -9,9 +9,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:41:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:40:25
    |
-41 |     let _ = join.select(posts::title);
+40 |     let _ = join.select(posts::title);
    |                         ^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -25,9 +25,9 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:47:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:46:18
    |
-47 |     let _ = join.select(lower(posts::title));
+46 |     let _ = join.select(lower(posts::title));
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -36,9 +36,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:47:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:46:25
    |
-47 |     let _ = join.select(lower(posts::title));
+46 |     let _ = join.select(lower(posts::title));
    |                         ^^^^^^^^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -52,19 +52,17 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>` for `lower::lower<posts::columns::title>`
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
-error[E0277]: the trait bound `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>: diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:49:25
+error[E0271]: type mismatch resolving `<diesel::expression::nullable::Nullable<posts::columns::title> as diesel::Expression>::SqlType == diesel::sql_types::Text`
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:48:25
    |
 32 | sql_function!(fn lower(x: Text) -> Text);
    | ----------------------------------------- required by this bound in `lower`
 ...
-49 |     let _ = join.select(lower(posts::title.nullable()));
-   |                         ^^^^^ the trait `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not implemented for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>`
+48 |     let _ = join.select(lower(posts::title.nullable()));
+   |                         ^^^^^ expected struct `diesel::sql_types::Nullable`, found struct `diesel::sql_types::Text`
    |
-   = help: the following implementations were found:
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::IsNullable> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
+   = note: expected struct `diesel::sql_types::Nullable<diesel::sql_types::Text>`
+              found struct `diesel::sql_types::Text`
    = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::expression::nullable::Nullable<posts::columns::title>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
@@ -129,25 +127,23 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>` for `lower::lower<posts::columns::title>`
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
-error[E0277]: the trait bound `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>: diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not satisfied
+error[E0271]: type mismatch resolving `<diesel::expression::nullable::Nullable<posts::columns::title> as diesel::Expression>::SqlType == diesel::sql_types::Text`
   --> $DIR/right_side_of_left_join_requires_nullable.rs:65:25
    |
 32 | sql_function!(fn lower(x: Text) -> Text);
    | ----------------------------------------- required by this bound in `lower`
 ...
 65 |     let _ = join.select(lower(posts::title.nullable()));
-   |                         ^^^^^ the trait `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not implemented for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>`
+   |                         ^^^^^ expected struct `diesel::sql_types::Nullable`, found struct `diesel::sql_types::Text`
    |
-   = help: the following implementations were found:
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::IsNullable> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
+   = note: expected struct `diesel::sql_types::Nullable<diesel::sql_types::Text>`
+              found struct `diesel::sql_types::Text`
    = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::expression::nullable::Nullable<posts::columns::title>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:72:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:74:18
    |
-72 |     let _ = join.select(posts::title);
+74 |     let _ = join.select(posts::title);
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -157,9 +153,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:72:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:74:25
    |
-72 |     let _ = join.select(posts::title);
+74 |     let _ = join.select(posts::title);
    |                         ^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -175,9 +171,9 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:78:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:80:18
    |
-78 |     let _ = join.select(lower(posts::title));
+80 |     let _ = join.select(lower(posts::title));
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -188,9 +184,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:78:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:80:25
    |
-78 |     let _ = join.select(lower(posts::title));
+80 |     let _ = join.select(lower(posts::title));
    |                         ^^^^^^^^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -206,25 +202,23 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>` for `lower::lower<posts::columns::title>`
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>, pets::table, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
-error[E0277]: the trait bound `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>: diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:80:25
+error[E0271]: type mismatch resolving `<diesel::expression::nullable::Nullable<posts::columns::title> as diesel::Expression>::SqlType == diesel::sql_types::Text`
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:82:25
    |
 32 | sql_function!(fn lower(x: Text) -> Text);
    | ----------------------------------------- required by this bound in `lower`
 ...
-80 |     let _ = join.select(lower(posts::title.nullable()));
-   |                         ^^^^^ the trait `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not implemented for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>`
+82 |     let _ = join.select(lower(posts::title.nullable()));
+   |                         ^^^^^ expected struct `diesel::sql_types::Nullable`, found struct `diesel::sql_types::Text`
    |
-   = help: the following implementations were found:
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::IsNullable> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
+   = note: expected struct `diesel::sql_types::Nullable<diesel::sql_types::Text>`
+              found struct `diesel::sql_types::Text`
    = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::expression::nullable::Nullable<posts::columns::title>`
 
 error[E0271]: type mismatch resolving `<diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>> as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:87:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:89:18
    |
-87 |     let _ = join.select(posts::title);
+89 |     let _ = join.select(posts::title);
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -232,9 +226,9 @@ error[E0271]: type mismatch resolving `<diesel::query_builder::SelectStatement<d
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<pets::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:87:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:89:25
    |
-87 |     let _ = join.select(posts::title);
+89 |     let _ = join.select(posts::title);
    |                         ^^^^^^^^^^^^ the trait `diesel::SelectableExpression<pets::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -248,9 +242,9 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0271]: type mismatch resolving `<diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>> as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:93:18
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:95:18
    |
-93 |     let _ = join.select(lower(posts::title));
+95 |     let _ = join.select(lower(posts::title));
    |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
    |
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -259,9 +253,9 @@ error[E0271]: type mismatch resolving `<diesel::query_builder::SelectStatement<d
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<pets::table>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:93:25
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:95:25
    |
-93 |     let _ = join.select(lower(posts::title));
+95 |     let _ = join.select(lower(posts::title));
    |                         ^^^^^^^^^^^^^^^^^^^ the trait `diesel::SelectableExpression<pets::table>` is not implemented for `posts::columns::title`
    |
    = help: the following implementations were found:
@@ -275,25 +269,23 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
    = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>` for `lower::lower<posts::columns::title>`
    = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
-error[E0277]: the trait bound `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>: diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not satisfied
-  --> $DIR/right_side_of_left_join_requires_nullable.rs:95:25
+error[E0271]: type mismatch resolving `<diesel::expression::nullable::Nullable<posts::columns::title> as diesel::Expression>::SqlType == diesel::sql_types::Text`
+  --> $DIR/right_side_of_left_join_requires_nullable.rs:97:25
    |
 32 | sql_function!(fn lower(x: Text) -> Text);
    | ----------------------------------------- required by this bound in `lower`
 ...
-95 |     let _ = join.select(lower(posts::title.nullable()));
-   |                         ^^^^^ the trait `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not implemented for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>`
+97 |     let _ = join.select(lower(posts::title.nullable()));
+   |                         ^^^^^ expected struct `diesel::sql_types::Nullable`, found struct `diesel::sql_types::Text`
    |
-   = help: the following implementations were found:
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::IsNullable> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-             <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
+   = note: expected struct `diesel::sql_types::Nullable<diesel::sql_types::Text>`
+              found struct `diesel::sql_types::Text`
    = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::expression::nullable::Nullable<posts::columns::title>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-   --> $DIR/right_side_of_left_join_requires_nullable.rs:102:18
+   --> $DIR/right_side_of_left_join_requires_nullable.rs:104:18
     |
-102 |     let _ = join.select(posts::title);
+104 |     let _ = join.select(posts::title);
     |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
     |
     = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -304,9 +296,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
     = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-   --> $DIR/right_side_of_left_join_requires_nullable.rs:102:25
+   --> $DIR/right_side_of_left_join_requires_nullable.rs:104:25
     |
-102 |     let _ = join.select(posts::title);
+104 |     let _ = join.select(posts::title);
     |                         ^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
     |
     = help: the following implementations were found:
@@ -323,9 +315,9 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
     = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<posts::columns::title>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::AppearsInFromClause<posts::table>>::Count == diesel::query_source::Never`
-   --> $DIR/right_side_of_left_join_requires_nullable.rs:108:18
+   --> $DIR/right_side_of_left_join_requires_nullable.rs:110:18
     |
-108 |     let _ = join.select(lower(posts::title));
+110 |     let _ = join.select(lower(posts::title));
     |                  ^^^^^^ expected struct `diesel::query_source::Once`, found struct `diesel::query_source::Never`
     |
     = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>>` for `posts::columns::title`
@@ -337,9 +329,9 @@ error[E0271]: type mismatch resolving `<posts::table as diesel::query_source::Ap
     = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
 error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpression<users::table>` is not satisfied
-   --> $DIR/right_side_of_left_join_requires_nullable.rs:108:25
+   --> $DIR/right_side_of_left_join_requires_nullable.rs:110:25
     |
-108 |     let _ = join.select(lower(posts::title));
+110 |     let _ = join.select(lower(posts::title));
     |                         ^^^^^^^^^^^^^^^^^^^ the trait `diesel::SelectableExpression<users::table>` is not implemented for `posts::columns::title`
     |
     = help: the following implementations were found:
@@ -356,17 +348,15 @@ error[E0277]: the trait bound `posts::columns::title: diesel::SelectableExpressi
     = note: required because of the requirements on the impl of `diesel::SelectableExpression<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>` for `lower::lower<posts::columns::title>`
     = note: required because of the requirements on the impl of `diesel::query_dsl::select_dsl::SelectDsl<lower::lower<posts::columns::title>>` for `diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<pets::table, diesel::query_builder::SelectStatement<diesel::query_source::joins::JoinOn<diesel::query_source::joins::Join<users::table, posts::table, diesel::query_source::joins::LeftOuter>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<posts::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>, diesel::query_source::joins::Inner>, diesel::expression::grouped::Grouped<diesel::expression::operators::Eq<diesel::expression::nullable::Nullable<pets::columns::user_id>, diesel::expression::nullable::Nullable<users::columns::id>>>>>`
 
-error[E0277]: the trait bound `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>: diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not satisfied
-   --> $DIR/right_side_of_left_join_requires_nullable.rs:110:25
+error[E0271]: type mismatch resolving `<diesel::expression::nullable::Nullable<posts::columns::title> as diesel::Expression>::SqlType == diesel::sql_types::Text`
+   --> $DIR/right_side_of_left_join_requires_nullable.rs:112:25
     |
 32  | sql_function!(fn lower(x: Text) -> Text);
     | ----------------------------------------- required by this bound in `lower`
 ...
-110 |     let _ = join.select(lower(posts::title.nullable()));
-    |                         ^^^^^ the trait `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` is not implemented for `diesel::expression::as_expression_impl::ExpressionImplHelper<diesel::expression::nullable::Nullable<posts::columns::title>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::IsNullable>`
+112 |     let _ = join.select(lower(posts::title.nullable()));
+    |                         ^^^^^ expected struct `diesel::sql_types::Nullable`, found struct `diesel::sql_types::Text`
     |
-    = help: the following implementations were found:
-              <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::IsNullable> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-              <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::IsNullable, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
-              <diesel::expression::as_expression_impl::ExpressionImplHelper<T, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull> as diesel::expression::as_expression_impl::AsExpressionHelper<ST>>
+    = note: expected struct `diesel::sql_types::Nullable<diesel::sql_types::Text>`
+               found struct `diesel::sql_types::Text`
     = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `diesel::expression::nullable::Nullable<posts::columns::title>`
diff --git a/diesel_compile_tests/tests/fail/user_defined_functions_follow_same_selection_rules.stderr b/diesel_compile_tests/tests/fail/user_defined_functions_follow_same_selection_rules.stderr
index f550475878e1..9f33ae0a0d51 100644
--- a/diesel_compile_tests/tests/fail/user_defined_functions_follow_same_selection_rules.stderr
+++ b/diesel_compile_tests/tests/fail/user_defined_functions_follow_same_selection_rules.stderr
@@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<foo::foo<diesel::expression::bound::Boun
 35 |     let _ = users::table.filter(name.eq(foo(1)));
    |                                      ^^ expected struct `diesel::sql_types::Integer`, found struct `diesel::sql_types::Text`
    |
-   = note: required because of the requirements on the impl of `diesel::expression::as_expression_impl::AsExpressionHelper<diesel::sql_types::Text>` for `diesel::expression::as_expression_impl::ExpressionImplHelper<foo::foo<diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>>, diesel::sql_types::is_nullable::NotNull, diesel::sql_types::is_nullable::NotNull>`
+   = note: required because of the requirements on the impl of `diesel::expression::AsExpression<diesel::sql_types::Text>` for `foo::foo<diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>>`
 
 error[E0277]: the trait bound `users::table: diesel::query_source::AppearsInFromClause<posts::table>` is not satisfied
   --> $DIR/user_defined_functions_follow_same_selection_rules.rs:38:10
diff --git a/diesel_derives/src/lib.rs b/diesel_derives/src/lib.rs
index 0e4b60ed0ae5..6d3652dbf0a2 100644
--- a/diesel_derives/src/lib.rs
+++ b/diesel_derives/src/lib.rs
@@ -932,12 +932,12 @@ pub fn derive_valid_grouping(input: TokenStream) -> TokenStream {
 /// #
 /// # table! { crates { id -> Integer, name -> VarChar, } }
 /// #
-/// use diesel::sql_types::{Foldable, Nullable};
+/// use diesel::sql_types::Foldable;
 ///
 /// sql_function! {
 ///     #[aggregate]
 ///     #[sql_name = "SUM"]
-///     fn sum<ST: Foldable>(expr: Nullable<ST>) -> ST::Sum;
+///     fn sum<ST: Foldable>(expr: ST) -> ST::Sum;
 /// }
 ///
 /// # fn main() {
diff --git a/diesel_tests/tests/types.rs b/diesel_tests/tests/types.rs
index e8755f5f6424..b0cc36f1c78f 100644
--- a/diesel_tests/tests/types.rs
+++ b/diesel_tests/tests/types.rs
@@ -1251,21 +1251,24 @@ where
     select(sql::<T>(sql_str)).first(&connection).unwrap()
 }
 
-use diesel::dsl::Eq;
 use diesel::expression::{is_aggregate, AsExpression, SqlLiteral, ValidGrouping};
 use diesel::query_builder::{QueryFragment, QueryId};
 use std::fmt::Debug;
 
 fn query_to_sql_equality<T, U>(sql_str: &str, value: U) -> bool
 where
-    U: AsExpression<T::Nullable> + Debug + Clone,
-    U::Expression: SelectableExpression<(), SqlType = T::Nullable>
-        + ValidGrouping<(), IsAggregate = is_aggregate::Never>
-        + QueryFragment<TestBackend>
-        + QueryId,
-    T: QueryId + SingleValue + SqlType + IntoNullable,
-    T::Nullable: SqlType + SingleValue,
-    Eq<SqlLiteral<T::Nullable>, U>: Expression<SqlType = Nullable<Bool>> + SelectableExpression<()>,
+    U: AsExpression<T> + Debug + Clone,
+    U::Expression: SelectableExpression<(), SqlType = T>
+        + ValidGrouping<(), IsAggregate = is_aggregate::Never>,
+    U::Expression: QueryFragment<TestBackend> + QueryId,
+    T: QueryId + SingleValue + SqlType,
+    <T as diesel::sql_types::SqlType>::IsNull:
+        diesel::sql_types::OneIsNullable<<T as diesel::sql_types::SqlType>::IsNull>,
+    <<T as diesel::sql_types::SqlType>::IsNull as diesel::sql_types::OneIsNullable<
+        <T as diesel::sql_types::SqlType>::IsNull,
+    >>::Out: diesel::sql_types::MaybeNullableType<diesel::sql_types::Bool>,
+    diesel::dsl::Nullable<diesel::dsl::Eq<SqlLiteral<T>, U>>:
+        Expression<SqlType = diesel::sql_types::Nullable<diesel::sql_types::Bool>>,
 {
     use diesel::dsl::sql;
     let connection = connection();
@@ -1273,7 +1276,7 @@ where
         sql::<T>(sql_str)
             .is_null()
             .and(value.clone().as_expression().is_null())
-            .or(sql::<T::Nullable>(sql_str).eq(value.clone())),
+            .or(sql::<T>(sql_str).eq(value.clone()).nullable()),
     );
     query
         .get_result::<Option<bool>>(&connection)