Merge pull request diesel-rs#946 from diesel-rs/sg-refactor-operators

Refactor `infix_predicate!`, add a prefix version

Author: sgrif

CHANGELOG.md

@@ -16,6 +16,18 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 [pg-network-0.13.1]: https://www.postgresql.org/docs/9.6/static/datatype-net-types.html
 [not-0.14.0]: http://docs.diesel.rs/diesel/expression/dsl/fn.not.html
 
+* Added `diesel_prefix_operator!` which behaves identically to
+  `diesel_postfix_operator!` (previously `postfix_predicate!`), but for
+  operators like `NOT` which use prefix notation.
+
+### Changed
+
+* `infix_predicate!` and `infix_expression!` have been renamed to
+  `diesel_infix_operator!`.
+
+* `postfix_predicate!` and `postfix_expression!` have been renamed to
+  `diesel_postfix_operator!`.
+
 ## [0.13.0] - 2017-05-15
 
 ### Added

diesel/src/expression/helper_types.rs

@@ -2,6 +2,7 @@
 //! AsExpr<Rhs, Lhs>>`. Since we often need to return concrete types, instead of
 //! a boxed trait object, these can be useful for writing concise return types.
 use super::{Expression, AsExpression};
+use super::grouped::Grouped;
 use types;
 
 pub type SqlTypeOf<Expr> = <Expr as Expression>::SqlType;
@@ -10,11 +11,11 @@ pub type AsExprOf<Item, Type> = <Item as AsExpression<Type>>::Expression;
 
 macro_rules! gen_helper_type {
     ($name:ident) => {
-        pub type $name<Lhs, Rhs> = super::predicates::$name<Lhs, AsExpr<Rhs, Lhs>>;
+        pub type $name<Lhs, Rhs> = super::operators::$name<Lhs, AsExpr<Rhs, Lhs>>;
     };
 
     ($name:ident, $tpe:ident) => {
-        pub type $name<Lhs, Rhs> = super::predicates::$name<
+        pub type $name<Lhs, Rhs> = super::operators::$name<
             Lhs,
             <Rhs as AsExpression<types::$tpe>>::Expression,
         >;
@@ -31,15 +32,15 @@ gen_helper_type!(And, Bool);
 gen_helper_type!(Like, VarChar);
 gen_helper_type!(NotLike, VarChar);
 
-pub type Between<Lhs, Rhs> = super::predicates::Between<Lhs,
-    super::predicates::And<AsExpr<Rhs, Lhs>, AsExpr<Rhs, Lhs>>>;
-pub type NotBetween<Lhs, Rhs> = super::predicates::NotBetween<Lhs,
-    super::predicates::And<AsExpr<Rhs, Lhs>, AsExpr<Rhs, Lhs>>>;
+pub type Between<Lhs, Rhs> = super::operators::Between<Lhs,
+    super::operators::And<AsExpr<Rhs, Lhs>, AsExpr<Rhs, Lhs>>>;
+pub type NotBetween<Lhs, Rhs> = super::operators::NotBetween<Lhs,
+    super::operators::And<AsExpr<Rhs, Lhs>, AsExpr<Rhs, Lhs>>>;
 /// The return type of `not(expr)`
-pub type Not<Expr> = super::not::Not<AsExprOf<Expr, types::Bool>>;
+pub type Not<Expr> = super::operators::Not<Grouped<AsExprOf<Expr, types::Bool>>>;
 
 #[doc(inline)]
-pub use super::predicates::{IsNull, IsNotNull, Asc, Desc};
+pub use super::operators::{IsNull, IsNotNull, Asc, Desc};
 #[doc(inline)]
 pub use super::array_comparison::EqAny;
 

diesel/src/expression/mod.rs

@@ -39,7 +39,7 @@ mod not;
 pub mod nullable;
 #[doc(hidden)]
 #[macro_use]
-pub mod predicates;
+pub mod operators;
 pub mod sql_literal;
 mod unchecked_bind;
 
@@ -64,11 +64,12 @@ pub use self::sql_literal::SqlLiteral;
 
 use backend::Backend;
 
-/// Represents a typed fragment of SQL. Apps should not need to implement this
-/// type directly, but it may be common to use this as type boundaries.
-/// Libraries should consider using
-/// [`infix_predicate!`](../macro.infix_predicate.html) or
-/// [`postfix_predicate!`](../macro.postfix_predicate.html) instead of
+/// Represents a typed fragment of SQL.
+///
+/// Apps should not need to implement this type directly, but it may be common
+/// to use this in where clauses. Libraries should consider using
+/// [`diesel_infix_operator!`](../macro.diesel_infix_operator.html) or
+/// [`diesel_postfix_operator!`](../macro.diesel_postfix_operator.html) instead of
 /// implementing this directly.
 pub trait Expression {
     type SqlType;

diesel/src/expression/not.rs

@@ -1,6 +1,6 @@
-use expression::*;
-use query_builder::*;
-use result::QueryResult;
+use expression::AsExpression;
+use expression::helper_types::Not;
+use expression::grouped::Grouped;
 use types::Bool;
 
 /// Creates a SQL `NOT` expression
@@ -31,42 +31,6 @@ use types::Bool;
 /// assert_eq!(Ok(2), users_not_with_name.first(&connection));
 /// # }
 /// ```
-pub fn not<T: AsExpression<Bool>>(expr: T) -> Not<T::Expression> {
-    Not(expr.as_expression())
+pub fn not<T: AsExpression<Bool>>(expr: T) -> Not<T> {
+    super::operators::Not::new(Grouped(expr.as_expression()))
 }
-
-#[doc(hidden)]
-#[derive(Debug, Clone, Copy)]
-pub struct Not<T>(T);
-
-impl<T: Expression<SqlType=Bool>> Expression for Not<T> {
-    type SqlType = Bool;
-}
-
-impl<T, QS> AppearsOnTable<QS> for Not<T> where
-    T: AppearsOnTable<QS>,
-    Not<T>: Expression,
-{
-}
-
-impl<T, QS> SelectableExpression<QS> for Not<T> where
-    T: SelectableExpression<QS>,
-    Not<T>: AppearsOnTable<QS>,
-{
-}
-
-impl<T: NonAggregate> NonAggregate for Not<T> {}
-
-impl<T, DB> QueryFragment<DB> for Not<T> where
-    DB: Backend,
-    T: QueryFragment<DB>,
-{
-    fn walk_ast(&self, mut out: AstPass<DB>) -> QueryResult<()> {
-        out.push_sql("NOT (");
-        self.0.walk_ast(out.reborrow())?;
-        out.push_sql(")");
-        Ok(())
-    }
-}
-
-impl_query_id!(Not<T>);