Impl sqlord for array (diesel-rs#1449)

* Add DropTable struct for ensured cleanup of one-off tables

* Impl SqlOrd for Array<T: SqlOrd>

Author: virome

CHANGELOG.md

@@ -27,6 +27,9 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * Added support for SQLite's `INSERT OR IGNORE` and MySQL's `INSERT IGNORE`
   via the `insert_or_ignore` function.
 
+* Trait `SqlOrd` is now implemented for `Array`, meaning min/max functions can be used
+  on Array columns (PostgreSQL only).
+
 ### Deprecated
 
 * Deprecated `impl_query_id!` in favor of `#[derive(QueryId)]`

diesel/src/types/ord.rs

@@ -14,3 +14,5 @@ impl SqlOrd for types::Interval {}
 impl SqlOrd for types::Time {}
 impl SqlOrd for types::Timestamp {}
 impl<T: SqlOrd + NotNull> SqlOrd for types::Nullable<T> {}
+#[cfg(feature = "postgres")]
+impl<T: SqlOrd> SqlOrd for types::Array<T> {}

diesel_tests/tests/expressions/mod.rs

@@ -1,7 +1,7 @@
 mod date_and_time;
 mod ops;
 
-use schema::{connection, NewUser, TestBackend};
+use schema::{connection, DropTable, NewUser, TestBackend};
 use schema::users::dsl::*;
 use diesel::*;
 use diesel::backend::Backend;
@@ -67,6 +67,58 @@ fn test_count_max() {
     assert_eq!(Ok(None::<i32>), source.first(&connection));
 }
 
+#[cfg(feature = "postgres")]
+table! {
+    number_arrays (na) {
+        na -> Array<Integer>,
+    }
+}
+
+#[test]
+#[cfg(feature = "postgres")]
+fn test_min_max_of_array() {
+    use self::number_arrays::dsl::*;
+
+    let connection = connection();
+    connection
+        .execute("CREATE TABLE number_arrays ( na INTEGER[] PRIMARY KEY )")
+        .unwrap();
+    let _bomb = DropTable {
+        connection: &connection,
+        table_name: "number_arrays",
+    };
+
+    insert_into(number_arrays)
+        .values(&vec![
+            na.eq(vec![1, 1, 100]),
+            na.eq(vec![1, 5, 5]),
+            na.eq(vec![5, 0]),
+        ])
+        .execute(&connection)
+        .unwrap();
+
+    let max_query = number_arrays.select(max(na));
+    let min_query = number_arrays.select(min(na));
+    assert_eq!(Ok(Some(vec![5, 0])), max_query.first(&connection));
+    assert_eq!(Ok(Some(vec![1, 1, 100])), min_query.first(&connection));
+
+    delete(number_arrays.filter(na.eq(vec![5, 0])))
+        .execute(&connection)
+        .unwrap();
+    assert_eq!(Ok(Some(vec![1, 5, 5])), max_query.first(&connection));
+    assert_eq!(Ok(Some(vec![1, 1, 100])), min_query.first(&connection));
+
+    delete(number_arrays.filter(na.eq(vec![1, 1, 100])))
+        .execute(&connection)
+        .unwrap();
+    assert_eq!(Ok(Some(vec![1, 5, 5])), max_query.first(&connection));
+    assert_eq!(Ok(Some(vec![1, 5, 5])), min_query.first(&connection));
+
+    delete(number_arrays).execute(&connection).unwrap();
+    assert_eq!(Ok(None::<Vec<i32>>), max_query.first(&connection));
+    assert_eq!(Ok(None::<Vec<i32>>), min_query.first(&connection));
+}
+
 #[test]
 fn max_returns_same_type_as_expression_being_maximized() {
     let connection = connection();

diesel_tests/tests/schema.rs

@@ -165,6 +165,20 @@ pub type TestConnection = MysqlConnection;
 
 pub type TestBackend = <TestConnection as Connection>::Backend;
 
+//Used to ensure cleanup of one-off tables, e.g. for a table created for a single test
+pub struct DropTable<'a> {
+    pub connection: &'a TestConnection,
+    pub table_name: &'static str,
+}
+
+impl<'a> Drop for DropTable<'a> {
+    fn drop(&mut self) {
+        self.connection
+            .execute(&format!("DROP TABLE {}", self.table_name))
+            .unwrap();
+    }
+}
+
 pub fn connection() -> TestConnection {
     let result = connection_without_transaction();
     #[cfg(feature = "sqlite")]