DATAMONGO-586 - Add initial support for arithmetic expressions.

ProjectionOperationBuilder now implements AggregationOperation in order to be able support aliased as well as non alias projection operation expressions. Added test case for arithmetic operations to AggregationTests. Added Product domain class to be able to demonstrate some meaningful arithmetic operations. Applied changes from code review. Added internal private remove method to ProjectionOperation to allow previous operation to support aliasing.

Author: Thomas Darimont

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ProjectionOperation.java

@@ -23,6 +23,7 @@
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
 import org.springframework.data.mongodb.core.aggregation.ProjectionOperation.ProjectionOperationBuilder.FieldProjection;
+import org.springframework.data.mongodb.core.aggregation.ProjectionOperation.ProjectionOperationBuilder.OperationProjection;
 import org.springframework.util.Assert;
 
 import com.mongodb.BasicDBObject;
@@ -72,7 +73,7 @@ protected ProjectionOperation and(Projection projection) {
 	 * @return
 	 */
 	public ProjectionOperationBuilder and(String name) {
-		return new ProjectionOperationBuilder(name, this);
+		return new ProjectionOperationBuilder(name, this, null);
 	}
 
 	/**
@@ -125,6 +126,16 @@ protected ExposedFields getFields() {
 		return fields;
 	}
 
+	/**
+	 * Removes the given projectionOperation from the list of current projection operations. Needed in order to support
+	 * aliasing.
+	 * 
+	 * @param projectionOperation
+	 */
+	private void remove(OperationProjection projectionOperation) {
+		this.projections.remove(projectionOperation);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
@@ -146,25 +157,28 @@ public DBObject toDBObject(AggregationOperationContext context) {
 	 * 
 	 * @author Oliver Gierke
 	 */
-	public static class ProjectionOperationBuilder {
+	public static class ProjectionOperationBuilder implements AggregationOperation {
 
 		private final String name;
 		private final ProjectionOperation operation;
+		private final OperationProjection previousProjection;
 
 		/**
 		 * Creates a new {@link ProjectionOperationBuilder} for the field with the given name on top of the given
 		 * {@link ProjectionOperation}.
 		 * 
 		 * @param name must not be {@literal null} or empty.
 		 * @param operation must not be {@literal null}.
+		 * @param previousProjection the previous operation projection, may be {@literal null}.
 		 */
-		public ProjectionOperationBuilder(String name, ProjectionOperation operation) {
+		public ProjectionOperationBuilder(String name, ProjectionOperation operation, OperationProjection previousProjection) {
 
 			Assert.hasText(name, "Field name must not be null or empty!");
 			Assert.notNull(operation, "ProjectionOperation must not be null!");
 
 			this.name = name;
 			this.operation = operation;
+			this.previousProjection = previousProjection;
 		}
 
 		/**
@@ -189,14 +203,88 @@ public ProjectionOperation nested(Fields fields) {
 			return this.operation.and(new NestedFieldProjection(name, fields));
 		}
 
-		public ProjectionOperation plus(Number number) {
+		/**
+		 * Allows to specify an alias for the previous projection operation.
+		 * 
+		 * @param string
+		 * @return
+		 */
+		public ProjectionOperation as(String alias) {
+
+			Assert.notNull(this.previousProjection, "previousProjection must not be null!");
+			this.operation.remove(this.previousProjection);
+			return this.operation.and(previousProjection.withAlias(alias));
+		}
+
+		/**
+		 * Generates an {@code $add} expression that adds the given number to the previously mentioned field.
+		 * 
+		 * @param number
+		 * @return
+		 */
+		public ProjectionOperationBuilder plus(Number number) {
+
 			Assert.notNull(number, "Number must not be null!");
 			return project("add", number);
 		}
 
-		public ProjectionOperation minus(Number number) {
+		/**
+		 * Generates an {@code $subtract} expression that subtracts the given number to the previously mentioned field.
+		 * 
+		 * @param number
+		 * @return
+		 */
+		public ProjectionOperationBuilder minus(Number number) {
+
 			Assert.notNull(number, "Number must not be null!");
-			return project("substract", number);
+			return project("subtract", number);
+		}
+
+		/**
+		 * Generates an {@code $multiply} expression that multiplies the given number with the previously mentioned field.
+		 * 
+		 * @param number
+		 * @return
+		 */
+		public ProjectionOperationBuilder multiply(Number number) {
+
+			Assert.notNull(number, "Number must not be null!");
+			return project("multiply", number);
+		}
+
+		/**
+		 * Generates an {@code $divide} expression that divides the previously mentioned field by the given number.
+		 * 
+		 * @param number
+		 * @return
+		 */
+		public ProjectionOperationBuilder divide(Number number) {
+
+			Assert.notNull(number, "Number must not be null!");
+			Assert.isTrue(Math.abs(number.intValue()) != 0, "Number must not be zero!");
+			return project("divide", number);
+		}
+
+		/**
+		 * Generates an {@code $mod} expression that divides the previously mentioned field by the given number and returns
+		 * the remainder.
+		 * 
+		 * @param number
+		 * @return
+		 */
+		public ProjectionOperationBuilder mod(Number number) {
+
+			Assert.notNull(number, "Number must not be null!");
+			Assert.isTrue(Math.abs(number.intValue()) != 0, "Number must not be zero!");
+			return project("mod", number);
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		public DBObject toDBObject(AggregationOperationContext context) {
+			return this.operation.toDBObject(context);
 		}
 
 		/**
@@ -206,8 +294,9 @@ public ProjectionOperation minus(Number number) {
 		 * @param values the values to be set for the projection operation.
 		 * @return
 		 */
-		public ProjectionOperation project(String operation, Object... values) {
-			return this.operation.and(new OperationProjection(name, operation, values));
+		public ProjectionOperationBuilder project(String operation, Object... values) {
+			OperationProjection projectionOperation = new OperationProjection(name, operation, name, values);
+			return new ProjectionOperationBuilder(name, this.operation.and(projectionOperation), projectionOperation);
 		}
 
 		/**
@@ -308,21 +397,27 @@ static class OperationProjection extends Projection {
 			private final String operation;
 			private final List<Object> values;
 
+			private final String aliasName;
+
 			/**
 			 * Creates a new {@link OperationProjection} for the given field.
 			 * 
 			 * @param name the name of the field to add the operation projection for, must not be {@literal null} or empty.
+			 * @param aliasName the name of the field alias to write that will hold the operation projection, must not be
+			 *          {@literal null} or empty.
 			 * @param operation the actual operation key, must not be {@literal null} or empty.
 			 * @param values the values to pass into the operation, must not be {@literal null}.
 			 */
-			public OperationProjection(String name, String operation, Object... values) {
+			public OperationProjection(String name, String operation, String aliasName, Object[] values) {
 
 				super(Fields.field(name));
 
+				Assert.hasText(aliasName, "aliasName must not be null or empty!");
 				Assert.hasText(operation, "Operation must not be null or empty!");
 				Assert.notNull(values, "Values must not be null!");
 
 				this.name = name;
+				this.aliasName = aliasName;
 				this.operation = operation;
 				this.values = Arrays.asList(values);
 			}
@@ -335,21 +430,32 @@ public OperationProjection(String name, String operation, Object... values) {
 			public DBObject toDBObject(AggregationOperationContext context) {
 
 				List<Object> values = buildReferences(context);
-				DBObject inner = new BasicDBObject(operation, values.size() == 1 ? values.get(0) : values.toArray());
+				DBObject inner = new BasicDBObject("$" + operation, values.toArray());
 
-				return new BasicDBObject(name, inner);
+				return new BasicDBObject(this.aliasName, inner);
 			}
 
 			private List<Object> buildReferences(AggregationOperationContext context) {
 
 				List<Object> result = new ArrayList<Object>(values.size());
+				result.add(context.getReference(this.name).toString());
 
 				for (Object element : values) {
 					result.add(element instanceof Field ? context.getReference((Field) element).toString() : element);
 				}
 
 				return result;
 			}
+
+			/**
+			 * Creates a new instance of this {@link OperationProjection} with the given alias.
+			 * 
+			 * @param aliasName the aliasName to set
+			 * @return
+			 */
+			public OperationProjection withAlias(String aliasName) {
+				return new OperationProjection(name, operation, aliasName, values.toArray());
+			}
 		}
 
 		static class NestedFieldProjection extends Projection {
@@ -398,4 +504,5 @@ public ExposedField getField() {
 
 		public abstract DBObject toDBObject(AggregationOperationContext context);
 	}
+
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationTests.java

@@ -82,6 +82,7 @@ public void cleanUp() {
 
 	private void cleanDb() {
 		mongoTemplate.dropCollection(INPUT_COLLECTION);
+		mongoTemplate.dropCollection(Product.class);
 		mongoTemplate.dropCollection(UserWithLikes.class);
 	}
 
@@ -421,6 +422,40 @@ public void returnFiveMostCommonLikesAggregationFrameworkExample() {
 		assertLikeStats(result.getMappedResults().get(4), "e", 3);
 	}
 
+	@Test
+	public void arithmenticOperatorsInProjectionExample() {
+
+		double taxRate = 0.19;
+		double netPrice = 1.99;
+		double discountRate = 0.05;
+		int spaceUnits = 3;
+		String productId = "P1";
+		String productName = "A";
+		mongoTemplate.insert(new Product(productId, productName, netPrice, spaceUnits, discountRate, taxRate));
+
+		TypedAggregation<Product> agg = newAggregation(Product.class, //
+				project("name", "netPrice") //
+						.and("netPrice").plus(1).as("netPricePlus1") //
+						.and("netPrice").minus(1).as("netPriceMinus1") //
+						.and("netPrice").multiply(2).as("netPriceMul2") //
+						.and("netPrice").divide(1.19).as("netPriceDiv119") //
+						.and("spaceUnits").mod(2).as("spaceUnitsMod2") //
+		);
+
+		AggregationResults<DBObject> result = mongoTemplate.aggregate(agg, DBObject.class);
+		List<DBObject> resultList = result.getMappedResults();
+
+		assertThat(resultList, is(notNullValue()));
+		assertThat((String) resultList.get(0).get("_id"), is(productId));
+		assertThat((String) resultList.get(0).get("name"), is(productName));
+		assertThat((Double) resultList.get(0).get("netPricePlus1"), is(netPrice + 1));
+		assertThat((Double) resultList.get(0).get("netPriceMinus1"), is(netPrice - 1));
+		assertThat((Double) resultList.get(0).get("netPriceMul2"), is(netPrice * 2));
+		assertThat((Double) resultList.get(0).get("netPriceDiv119"), is(netPrice / 1.19));
+		assertThat((Integer) resultList.get(0).get("spaceUnitsMod2"), is(spaceUnits % 2));
+
+	}
+
 	private void assertLikeStats(LikeStats like, String id, long count) {
 
 		assertThat(like, is(notNullValue()));

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/Product.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.aggregation;
+
+/**
+ * @author Thomas Darimont
+ */
+public class Product {
+	String id;
+	String name;
+	double netPrice;
+	int spaceUnits;
+	double discountRate;
+	double taxRate;
+
+	public Product() {}
+
+	public Product(String id, String name, double netPrice, int spaceUnits, double discountRate, double taxRate) {
+		this.id = id;
+		this.name = name;
+		this.netPrice = netPrice;
+		this.spaceUnits = spaceUnits;
+		this.discountRate = discountRate;
+		this.taxRate = taxRate;
+	}
+}