Merge pull request diesel-rs#2068 from diesel-rs/sg-nullable-expr-methods

Implement all expression method traits for nullable types

Author: weiznich

CHANGELOG.md

@@ -15,6 +15,8 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * Added `DatabaseErrorKind::ReadOnlyTransaction` to allow applications to
   handle errors caused by writing when only allowed to read.
 
+* All expression methods can now be called on expressions of nullable types.
+
 ### Removed
 
 * All previously deprecated items have been removed.

diesel/src/expression_methods/bool_expression_methods.rs

@@ -1,10 +1,10 @@
 use expression::grouped::Grouped;
 use expression::operators::{And, Or};
 use expression::{AsExpression, Expression};
-use sql_types::Bool;
+use sql_types::{Bool, Nullable};
 
 /// Methods present on boolean expressions
-pub trait BoolExpressionMethods: Expression<SqlType = Bool> + Sized {
+pub trait BoolExpressionMethods: Expression + Sized {
     /// Creates a SQL `AND` expression
     ///
     /// # Example
@@ -37,8 +37,8 @@ pub trait BoolExpressionMethods: Expression<SqlType = Bool> + Sized {
     /// assert_eq!(expected, data);
     /// #     Ok(())
     /// # }
-    fn and<T: AsExpression<Bool>>(self, other: T) -> And<Self, T::Expression> {
-        And::new(self.as_expression(), other.as_expression())
+    fn and<T: AsExpression<Self::SqlType>>(self, other: T) -> And<Self, T::Expression> {
+        And::new(self, other.as_expression())
     }
 
     /// Creates a SQL `OR` expression
@@ -79,9 +79,23 @@ pub trait BoolExpressionMethods: Expression<SqlType = Bool> + Sized {
     /// assert_eq!(expected, data);
     /// #     Ok(())
     /// # }
-    fn or<T: AsExpression<Bool>>(self, other: T) -> Grouped<Or<Self, T::Expression>> {
+    fn or<T: AsExpression<Self::SqlType>>(self, other: T) -> Grouped<Or<Self, T::Expression>> {
         Grouped(Or::new(self, other.as_expression()))
     }
 }
 
-impl<T: Expression<SqlType = Bool>> BoolExpressionMethods for T {}
+impl<T> BoolExpressionMethods for T
+where
+    T: Expression,
+    T::SqlType: BoolOrNullableBool,
+{
+}
+
+#[doc(hidden)]
+/// Marker trait used to implement `BoolExpressionMethods` on the appropriate
+/// types. Once coherence takes associated types into account, we can remove
+/// this trait.
+pub trait BoolOrNullableBool {}
+
+impl BoolOrNullableBool for Bool {}
+impl BoolOrNullableBool for Nullable<Bool> {}

diesel/src/pg/expression/date_and_time.rs

@@ -2,13 +2,14 @@ use expression::Expression;
 use pg::Pg;
 use query_builder::*;
 use result::QueryResult;
-use sql_types::{Date, Timestamp, Timestamptz, VarChar};
+use sql_types::{Date, NotNull, Nullable, Timestamp, Timestamptz, VarChar};
 
 /// Marker trait for types which are valid in `AT TIME ZONE` expressions
 pub trait DateTimeLike {}
 impl DateTimeLike for Date {}
 impl DateTimeLike for Timestamp {}
 impl DateTimeLike for Timestamptz {}
+impl<T: NotNull + DateTimeLike> DateTimeLike for Nullable<T> {}
 
 #[derive(Debug, Copy, Clone, QueryId, NonAggregate)]
 pub struct AtTimeZone<Ts, Tz> {

diesel/src/pg/expression/expression_methods.rs

@@ -138,7 +138,7 @@ pub trait PgTimestampExpressionMethods: Expression + Sized {
 impl<T: Expression> PgTimestampExpressionMethods for T where T::SqlType: DateTimeLike {}
 
 /// PostgreSQL specific methods present on array expressions.
-pub trait PgArrayExpressionMethods<ST>: Expression<SqlType = Array<ST>> + Sized {
+pub trait PgArrayExpressionMethods: Expression + Sized {
     /// Creates a PostgreSQL `&&` expression.
     ///
     /// This operator returns whether two arrays have common elements.
@@ -300,7 +300,21 @@ pub trait PgArrayExpressionMethods<ST>: Expression<SqlType = Array<ST>> + Sized
     }
 }
 
-impl<T, ST> PgArrayExpressionMethods<ST> for T where T: Expression<SqlType = Array<ST>> {}
+impl<T> PgArrayExpressionMethods for T
+where
+    T: Expression,
+    T::SqlType: ArrayOrNullableArray,
+{
+}
+
+#[doc(hidden)]
+/// Marker trait used to implement `ArrayExpressionMethods` on the appropriate
+/// types. Once coherence takes associated types into account, we can remove
+/// this trait.
+pub trait ArrayOrNullableArray {}
+
+impl<T> ArrayOrNullableArray for Array<T> {}
+impl<T> ArrayOrNullableArray for Nullable<Array<T>> {}
 
 use expression::operators::{Asc, Desc};