add some multirange operations support

diesel/src/pg/expression/expression_methods.rs

@@ -4,7 +4,7 @@ pub(in crate::pg) use self::private::{
     ArrayOrNullableArray, InetOrCidr, JsonIndex, JsonOrNullableJson,
     JsonOrNullableJsonOrJsonbOrNullableJsonb, JsonRemoveIndex, JsonbOrNullableJsonb,
     MaybeNullableValue, MultirangeOrNullableMultirange, MultirangeOrRangeMaybeNullable,
-    RangeHelper, RangeOrNullableRange, TextArrayOrNullableTextArray, TextOrNullableText,
+    RangeOrMultirange, RangeOrNullableRange, TextArrayOrNullableTextArray, TextOrNullableText,
 };
 use super::date_and_time::{AtTimeZone, DateTimeLike};
 use super::operators::*;
@@ -836,6 +836,7 @@ pub trait PgRangeExpressionMethods: Expression + Sized {
     /// #     posts {
     /// #         id -> Integer,
     /// #         versions -> Range<Integer>,
+    /// #         age -> Multirange<Integer>,
     /// #     }
     /// # }
     /// #
@@ -848,10 +849,10 @@ pub trait PgRangeExpressionMethods: Expression + Sized {
     /// #     use std::collections::Bound;
     /// #     let conn = &mut establish_connection();
     /// #     diesel::sql_query("DROP TABLE IF EXISTS posts").execute(conn).unwrap();
-    /// #     diesel::sql_query("CREATE TABLE posts (id SERIAL PRIMARY KEY, versions INT4RANGE NOT NULL)").execute(conn).unwrap();
+    /// #     diesel::sql_query("CREATE TABLE posts (id SERIAL PRIMARY KEY, versions INT4RANGE NOT NULL, age INT4MULTIRANGE)").execute(conn).unwrap();
     /// #
     /// diesel::insert_into(posts)
-    ///     .values(versions.eq((Bound::Included(5), Bound::Unbounded)))
+    ///     .values((versions.eq(5..), age.eq(vec![1..18, 60..99])))
     ///     .execute(conn)?;
     ///
     /// let cool_posts = posts.select(id)
@@ -863,14 +864,24 @@ pub trait PgRangeExpressionMethods: Expression + Sized {
     ///     .filter(versions.contains(1))
     ///     .load::<i32>(conn)?;
     /// assert!(amazing_posts.is_empty());
+    ///
+    /// let cool_posts = posts.select(id)
+    ///     .filter(age.contains(10))
+    ///     .load::<i32>(conn)?;
+    /// assert_eq!(vec![1], cool_posts);
+    ///
+    /// let amazing_posts = posts.select(id)
+    ///     .filter(age.contains(20))
+    ///     .load::<i32>(conn)?;
+    /// assert!(amazing_posts.is_empty());
     /// #     Ok(())
     /// # }
     /// ```
     fn contains<T>(self, other: T) -> dsl::RangeContains<Self, T>
     where
-        Self::SqlType: RangeHelper,
-        <Self::SqlType as RangeHelper>::Inner: SqlType + TypedExpressionType,
-        T: AsExpression<<Self::SqlType as RangeHelper>::Inner>,
+        Self::SqlType: RangeOrMultirange,
+        <Self::SqlType as RangeOrMultirange>::Inner: SqlType + TypedExpressionType,
+        T: AsExpression<<Self::SqlType as RangeOrMultirange>::Inner>,
     {
         Grouped(Contains::new(self, other.as_expression()))
     }
@@ -1779,7 +1790,7 @@ pub trait PgRangeExpressionMethods: Expression + Sized {
 impl<T> PgRangeExpressionMethods for T
 where
     T: Expression,
-    T::SqlType: RangeOrNullableRange,
+    T::SqlType: MultirangeOrRangeMaybeNullable,
 {
 }
 
@@ -3466,12 +3477,20 @@ pub(in crate::pg) mod private {
     impl TextOrNullableText for Nullable<Text> {}
 
     /// Marker trait used to extract the inner type
-    /// of our `Range<T>` sql type, used to implement `PgRangeExpressionMethods`
-    pub trait RangeHelper: SqlType + SingleValue {
+    /// of our `Range<T>` and `Multirange<T>` sql type, used to implement `PgRangeExpressionMethods`
+    pub trait RangeOrMultirange: SqlType + SingleValue {
         type Inner: SingleValue;
     }
 
-    impl<ST> RangeHelper for Range<ST>
+    impl<ST> RangeOrMultirange for Range<ST>
+    where
+        Self: 'static,
+        ST: SingleValue,
+    {
+        type Inner = ST;
+    }
+
+    impl<ST> RangeOrMultirange for Multirange<ST>
     where
         Self: 'static,
         ST: SingleValue,

diesel/src/pg/expression/helper_types.rs

@@ -56,7 +56,7 @@ pub type ArrayContains<Lhs, Rhs> = Contains<Lhs, Rhs>;
 pub type RangeContains<Lhs, Rhs> = Grouped<
     super::operators::Contains<
         Lhs,
-        AsExprOf<Rhs, <SqlTypeOf<Lhs> as super::expression_methods::RangeHelper>::Inner>,
+        AsExprOf<Rhs, <SqlTypeOf<Lhs> as super::expression_methods::RangeOrMultirange>::Inner>,
     >,
 >;