Implement 'min' function based on SQLs 'MIN'

Author: palango

CHANGELOG.md

@@ -15,6 +15,8 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
   added to `Cargo.toml`, you'll gain `Arbitrary` implementations for everything
   in `diesel::data_types`.
 
+* Add `min` function that mirrors SQLs MIN.
+
 ## [0.2.0] - 2015-11-30
 
 ### Added

diesel/src/expression/min.rs

@@ -0,0 +1,33 @@
+use query_builder::{QueryBuilder, BuildQueryResult};
+use super::{Expression, SelectableExpression};
+use types::{SqlOrd, NativeSqlType};
+
+/// Represents a SQL `MIN` function. This function can only take types which are
+/// ordered.
+pub fn min<ST, T>(t: T) -> Min<T> where
+    ST: NativeSqlType + SqlOrd,
+    T: Expression<SqlType=ST>,
+{
+    Min {
+        target: t,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Min<T: Expression> {
+    target: T,
+}
+
+impl<T: Expression> Expression for Min<T> {
+    type SqlType = T::SqlType;
+
+    fn to_sql(&self, out: &mut QueryBuilder) -> BuildQueryResult {
+        out.push_sql("MIN(");
+        try!(self.target.to_sql(out));
+        out.push_sql(")");
+        Ok(())
+    }
+}
+
+impl<T: Expression, QS> SelectableExpression<QS> for Min<T> {
+}

diesel/src/expression/mod.rs

@@ -35,6 +35,8 @@ pub mod helper_types;
 #[doc(hidden)]
 pub mod max;
 #[doc(hidden)]
+pub mod min;
+#[doc(hidden)]
 pub mod ordering;
 #[doc(hidden)]
 pub mod predicates;
@@ -52,6 +54,8 @@ pub mod dsl {
     pub use super::functions::date_and_time::*;
     #[doc(inline)]
     pub use super::max::max;
+    #[doc(inline)]
+    pub use super::min::min;
 
     pub use super::extensions::*;
 }

diesel_tests/tests/compile-fail/min_requires_ord.rs

@@ -0,0 +1,16 @@
+#[macro_use]
+extern crate diesel;
+
+use diesel::*;
+use diesel::expression::min;
+
+table! {
+    stuff (b) {
+        b -> Bool,
+    }
+}
+
+fn main() {
+    let source = stuff::table.select(min(stuff::b));
+    //~^ ERROR E0277
+}

diesel_tests/tests/expressions/mod.rs

@@ -73,7 +73,7 @@ fn test_count_max() {
 }
 
 #[test]
-fn max_returns_same_type_as_expression_being_maxed() {
+fn max_returns_same_type_as_expression_being_maximized() {
     let connection = connection();
     setup_users_table(&connection);
     let source = users.select(max(name));
@@ -136,6 +136,65 @@ fn max_accepts_all_numeric_string_and_date_types() {
     let _ = users.select(max(arbitrary::<types::Nullable<types::Text>>()));
 }
 
+#[test]
+fn test_count_min() {
+    use self::numbers::columns::*;
+    use self::numbers::table as numbers;
+
+    let connection = connection();
+    connection.execute("CREATE TABLE numbers (n integer)").unwrap();
+    connection.execute("INSERT INTO numbers (n) VALUES (2), (1), (5)").unwrap();
+    let source = numbers.select(min(n));
+
+    assert_eq!(Ok(1), source.first(&connection));
+    connection.execute("DELETE FROM numbers WHERE n = 1").unwrap();
+    assert_eq!(Ok(2), source.first(&connection));
+}
+
+#[test]
+fn min_returns_same_type_as_expression_being_minimized() {
+    let connection = connection();
+    setup_users_table(&connection);
+    let source = users.select(min(name));
+
+    let data: &[_] = &[
+        NewUser::new("B", None),
+        NewUser::new("C", None),
+        NewUser::new("A", None),
+    ];
+    insert(data).into(users).execute(&connection).unwrap();
+    assert_eq!(Ok("A".to_string()), source.first(&connection));
+    connection.execute("DELETE FROM users WHERE name = 'A'").unwrap();
+    assert_eq!(Ok("B".to_string()), source.first(&connection));
+}
+
+#[test]
+fn min_accepts_all_numeric_string_and_date_types() {
+    let _ = users.select(min(arbitrary::<types::SmallSerial>()));
+    let _ = users.select(min(arbitrary::<types::Serial>()));
+    let _ = users.select(min(arbitrary::<types::BigSerial>()));
+    let _ = users.select(min(arbitrary::<types::SmallInt>()));
+    let _ = users.select(min(arbitrary::<types::Integer>()));
+    let _ = users.select(min(arbitrary::<types::BigInt>()));
+    let _ = users.select(min(arbitrary::<types::Float>()));
+    let _ = users.select(min(arbitrary::<types::Double>()));
+
+    let _ = users.select(min(arbitrary::<types::VarChar>()));
+    let _ = users.select(min(arbitrary::<types::Text>()));
+
+    let _ = users.select(min(arbitrary::<types::Nullable<types::SmallSerial>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::Serial>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::BigSerial>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::SmallInt>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::Integer>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::BigInt>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::Float>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::Double>>()));
+
+    let _ = users.select(min(arbitrary::<types::Nullable<types::VarChar>>()));
+    let _ = users.select(min(arbitrary::<types::Nullable<types::Text>>()));
+}
+
 sql_function!(coalesce, coalesce_t, (x: types::Nullable<types::VarChar>, y: types::VarChar) -> types::VarChar);
 
 #[test]