Merge pull request diesel-rs#1666 from diesel-rs/sg-parse-way-too-much-shit

Allow bounds on type parameters in `sql_function!`

Author: sgrif

diesel/src/expression/functions/aggregate_ordering.rs

@@ -1,89 +1,39 @@
-use backend::Backend;
-use expression::Expression;
-use query_builder::*;
-use result::QueryResult;
 use sql_types::{IntoNullable, SqlOrd};
 
-macro_rules! ord_function {
-    ($fn_name:ident, $type_name:ident, $operator:expr, $docs:expr) => {
-        #[doc=$docs]
-        pub fn $fn_name<ST, T>(t: T) -> $type_name<T> where
-            ST: SqlOrd,
-            T: Expression<SqlType=ST>,
-        {
-            $type_name {
-                target: t,
-            }
-        }
-
-        #[derive(Debug, Clone, Copy, QueryId)]
-        #[doc(hidden)]
-        pub struct $type_name<T> {
-            target: T,
-        }
-
-        impl<T: Expression> Expression for $type_name<T> where
-            T::SqlType: IntoNullable,
-        {
-            type SqlType = <T::SqlType as IntoNullable>::Nullable;
-        }
-
-        impl<T, DB> QueryFragment<DB> for $type_name<T> where
-            T: Expression + QueryFragment<DB>,
-            DB: Backend,
-        {
-            fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
-                out.push_sql(concat!($operator, "("));
-                self.target.walk_ast(out.reborrow())?;
-                out.push_sql(")");
-                Ok(())
-            }
-        }
-
-        impl_selectable_expression!($type_name<T>);
-    }
+sql_function! {
+    /// Represents a SQL `MAX` function. This function can only take types which are
+    /// ordered.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate diesel;
+    /// # include!("../../doctest_setup.rs");
+    /// # use diesel::dsl::*;
+    /// #
+    /// # fn main() {
+    /// #     use schema::animals::dsl::*;
+    /// #     let connection = establish_connection();
+    /// assert_eq!(Ok(Some(8)), animals.select(max(legs)).first(&connection));
+    /// # }
+    fn max<ST: SqlOrd + IntoNullable>(expr: ST) -> ST::Nullable;
 }
 
-ord_function!(
-    max,
-    Max,
-    "MAX",
-    "Represents a SQL `MAX` function. This function can only take types which are
-ordered.
-
-# Examples
-
-```rust
-# #[macro_use] extern crate diesel;
-# include!(\"../../doctest_setup.rs\");
-# use diesel::dsl::*;
-#
-# fn main() {
-#     use schema::animals::dsl::*;
-#     let connection = establish_connection();
-assert_eq!(Ok(Some(8)), animals.select(max(legs)).first(&connection));
-# }
-"
-);
-
-ord_function!(
-    min,
-    Min,
-    "MIN",
-    "Represents a SQL `MIN` function. This function can only take types which are
-ordered.
-
-# Examples
-
-```rust
-# #[macro_use] extern crate diesel;
-# include!(\"../../doctest_setup.rs\");
-# use diesel::dsl::*;
-#
-# fn main() {
-#     use schema::animals::dsl::*;
-#     let connection = establish_connection();
-assert_eq!(Ok(Some(4)), animals.select(min(legs)).first(&connection));
-# }
-"
-);
+sql_function! {
+    /// Represents a SQL `MIN` function. This function can only take types which are
+    /// ordered.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate diesel;
+    /// # include!("../../doctest_setup.rs");
+    /// # use diesel::dsl::*;
+    /// #
+    /// # fn main() {
+    /// #     use schema::animals::dsl::*;
+    /// #     let connection = establish_connection();
+    /// assert_eq!(Ok(Some(4)), animals.select(min(legs)).first(&connection));
+    /// # }
+    fn min<ST: SqlOrd + IntoNullable>(expr: ST) -> ST::Nullable;
+}

diesel/src/expression/functions/helper_types.rs

@@ -14,10 +14,10 @@ pub type not<Expr> = operators::Not<Grouped<AsExprOf<Expr, Bool>>>;
 pub type Not<Expr> = not<Expr>;
 
 /// The return type of [`max(expr)`](../dsl/fn.max.html)
-pub type max<Expr> = super::aggregate_ordering::Max<Expr>;
+pub type max<Expr> = super::aggregate_ordering::max::HelperType<SqlTypeOf<Expr>, Expr>;
 
 /// The return type of [`min(expr)`](../dsl/fn.min.html)
-pub type min<Expr> = super::aggregate_ordering::Min<Expr>;
+pub type min<Expr> = super::aggregate_ordering::min::HelperType<SqlTypeOf<Expr>, Expr>;
 
 /// The return type of [`sum(expr)`](../dsl/fn.sum.html)
 pub type sum<Expr> = super::aggregate_folding::sum::HelperType<SqlTypeOf<Expr>, Expr>;

diesel/src/expression/functions/mod.rs

@@ -91,6 +91,28 @@ macro_rules! sql_function_body {
 #[macro_export]
 #[doc(hidden)]
 macro_rules! __diesel_sql_function_body {
+    // Entry point with type arguments. Pull out the rest of the body.
+    (
+        data = (
+            meta = $meta:tt,
+            fn_name = $fn_name:tt,
+        ),
+        type_args = $type_args:tt,
+        type_args_with_bounds = $type_args_with_bounds:tt,
+        unparsed_tokens = (
+            $args:tt -> $return_type:ty $(;)*
+        ),
+    ) => {
+        __diesel_sql_function_body! {
+            meta = $meta,
+            fn_name = $fn_name,
+            type_args = $type_args,
+            type_args_with_bounds = $type_args_with_bounds,
+            args = $args,
+            return_type = $return_type,
+        }
+    };
+
     // Entry point. We need to search the meta items for our special attributes
     (
         meta = $meta:tt,
@@ -372,16 +394,16 @@ macro_rules! sql_function {
     (
         $(#$meta:tt)*
         fn $fn_name:ident
-            <$($type_arg:ident $(: $bound:path)*),* $(,)*>
-            $args:tt -> $return_type:ty $(;)*
+        <
+        $($tokens:tt)*
     ) => {
-        __diesel_sql_function_body!(
-            meta = ($(#$meta)*),
-            fn_name = $fn_name,
-            type_args = ($($type_arg,)*),
-            type_args_with_bounds = ($($type_arg $(: $bound)*,)*),
-            args = $args,
-            return_type = $return_type,
+        __diesel_parse_type_args!(
+            data = (
+                meta = ($(#$meta)*),
+                fn_name = $fn_name,
+            ),
+            callback = __diesel_sql_function_body,
+            tokens = ($($tokens)*),
         );
     };