DATAMONGO-586 - Next round of polishing.

Refined the way the aggregation pipeline gets rendered into a DBObject. More tests. Added $avg and shortcut methods to GroupOperations. Fixed ProjectionOperation to use 1 for implicit references. Made ProjectionOperation publicly visible. Added automatic result unwrapping. API consistency, tests, JavaDoc polish.

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

@@ -311,13 +311,12 @@ public interface MongoOperations {
 	 * 
 	 * @param aggregation The {@link TypedAggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
-	 * @param inputCollectionName The name of the input collection to use for the aggreation.
+	 * @param collectionName The name of the input collection to use for the aggreation.
 	 * @param outputType The parameterized type of the returned list, must not be {@literal null}.
 	 * @return The results of the aggregation operation.
 	 * @since 1.3
 	 */
-	<I, O> AggregationResults<O> aggregate(TypedAggregation<I, O> aggregation, String inputCollectionName,
+	<O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, String collectionName, Class<O> outputType);
-			Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class. The name of the
@@ -329,33 +328,33 @@ public interface MongoOperations {
 	 * @return The results of the aggregation operation.
 	 * @since 1.3
 	 */
-	<I, O> AggregationResults<O> aggregate(TypedAggregation<I, O> aggregation, Class<O> outputType);
+	<O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class.
 	 * 
-	 * @param inputType the inputType where the aggregation operation will read from, must not be {@literal null} or
-	 *          empty.
 	 * @param aggregation The {@link Aggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
+	 * @param inputType the inputType where the aggregation operation will read from, must not be {@literal null} or
+	 *          empty.
 	 * @param outputType The parameterized type of the returned list, must not be {@literal null}.
 	 * @return The results of the aggregation operation.
 	 * @since 1.3
 	 */
-	<I, O> AggregationResults<O> aggregate(Class<I> inputType, Aggregation<I, O> aggregation, Class<O> outputType);
+	<O> AggregationResults<O> aggregate(Aggregation aggregation, Class<?> inputType, Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class.
 	 * 
-	 * @param inputCollectionName the collection where the aggregation operation will read from, must not be
-	 *          {@literal null} or empty.
 	 * @param aggregation The {@link Aggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
+	 * @param collectionName the collection where the aggregation operation will read from, must not be {@literal null} or
+	 *          empty.
 	 * @param outputType The parameterized type of the returned list, must not be {@literal null}.
 	 * @return The results of the aggregation operation.
 	 * @since 1.3
 	 */
-	<O> AggregationResults<O> aggregate(String inputCollectionName, Aggregation<?, O> aggregation, Class<O> outputType);
+	<O> AggregationResults<O> aggregate(Aggregation aggregation, String collectionName, Class<O> outputType);
 
 	/**
 	 * Execute a map-reduce operation. The map-reduce operation will be formed with an output type of INLINE

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

@@ -54,7 +54,10 @@ import org.springframework.data.mapping.model.BeanWrapper;
 import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.mongodb.core.aggregation.Fields;
+import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
@@ -1215,31 +1218,47 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	@Override
-	public <I, O> AggregationResults<O> aggregate(TypedAggregation<I, O> aggregation, Class<O> outputType) {
+	public <O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, Class<O> outputType) {
 		return aggregate(aggregation, determineCollectionName(aggregation.getInputType()), outputType);
 	}
 
 	@Override
-	public <I, O> AggregationResults<O> aggregate(TypedAggregation<I, O> aggregation, String inputCollectionName,
+	public <O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, String inputCollectionName,
 			Class<O> outputType) {
-		return aggregate(inputCollectionName, aggregation, outputType);
+
+		Assert.notNull(aggregation, "Aggregation pipeline must not be null!");
+
+		AggregationOperationContext context = new TypeBasedAggregationOperationContext(aggregation.getInputType(),
+				mappingContext, queryMapper);
+		return aggregate(aggregation, inputCollectionName, outputType, context);
 	}
 
-	public <I, O> AggregationResults<O> aggregate(Class<I> inputType, Aggregation<I, O> aggregation, Class<O> outputType) {
+	@Override
-		return aggregate(determineCollectionName(inputType), aggregation, outputType);
+	public <O> AggregationResults<O> aggregate(Aggregation aggregation, Class<?> inputType, Class<O> outputType) {
+
+		return aggregate(aggregation, determineCollectionName(inputType), outputType,
+				new TypeBasedAggregationOperationContext(inputType, mappingContext, queryMapper));
 	}
 
-	public <O> AggregationResults<O> aggregate(String inputCollectionName, Aggregation<? extends Object, O> aggregation,
+	@Override
-			Class<O> outputType) {
+	public <O> AggregationResults<O> aggregate(Aggregation aggregation, String collectionName, Class<O> outputType) {
+		return aggregate(aggregation, collectionName, outputType, null);
+	}
 
-		Assert.notNull(inputCollectionName, "Collection name is missing");
+	protected <O> AggregationResults<O> aggregate(Aggregation aggregation, String collectionName, Class<O> outputType,
-		Assert.notNull(aggregation, "Aggregation pipeline is missing");
+			AggregationOperationContext context) {
-		Assert.notNull(outputType, "Entity class is missing");
 
-		// prepare command
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
-		DBObject command = aggregation.toDbObject(inputCollectionName);
+		Assert.notNull(aggregation, "Aggregation pipeline must not be null!");
+		Assert.notNull(outputType, "Output type must not be null!");
+
+		AggregationOperationContext rootContext = context == null ? Aggregation.DEFAULT_CONTEXT : context;
+		DBObject command = aggregation.toDbObject(collectionName, rootContext);
+
+		if (LOGGER.isDebugEnabled()) {
+			LOGGER.debug("Executing aggregation: {}", serializeToJsonSafely(command));
+		}
 
-		// execute command
 		CommandResult commandResult = executeCommand(command);
 		handleCommandError(commandResult, command);
 
@@ -1247,7 +1266,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		@SuppressWarnings("unchecked")
 		Iterable<DBObject> resultSet = (Iterable<DBObject>) commandResult.get("result");
 		List<O> mappedResults = new ArrayList<O>();
-		DbObjectCallback<O> callback = new ReadDbObjectCallback<O>(mongoConverter, outputType);
+		DbObjectCallback<O> callback = new UnwrapAndReadDbObjectCallback<O>(mongoConverter, outputType);
+
 		for (DBObject dbObject : resultSet) {
 			mappedResults.add(callback.doWith(dbObject));
 		}
@@ -1920,6 +1940,35 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 	}
 
+	class UnwrapAndReadDbObjectCallback<T> extends ReadDbObjectCallback<T> {
+
+		public UnwrapAndReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type) {
+			super(reader, type);
+		}
+
+		@Override
+		public T doWith(DBObject object) {
+
+			Object idField = object.get(Fields.UNDERSCORE_ID);
+
+			if (!(idField instanceof DBObject)) {
+				return super.doWith(object);
+			}
+
+			DBObject toMap = new BasicDBObject();
+			DBObject nested = (DBObject) idField;
+			toMap.putAll(nested);
+
+			for (String key : object.keySet()) {
+				if (!Fields.UNDERSCORE_ID.equals(key)) {
+					toMap.put(key, object.get(key));
+				}
+			}
+
+			return super.doWith(toMap);
+		}
+	}
+
 	private enum DefaultWriteConcernResolver implements WriteConcernResolver {
 
 		INSTANCE;

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

@@ -1,58 +0,0 @@
-/*
- * 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;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-
-/**
- * @author Thomas Darimont
- */
-abstract class AbstractAggregateOperation implements AggregationOperation {
-	private final String operationName;
-
-	/**
-	 * @param operationName
-	 */
-	public AbstractAggregateOperation(String operationName) {
-		this.operationName = operationName;
-	}
-
-	public String getOperationName() {
-		return operationName;
-	}
-
-	public String getOperationCommand() {
-		return OPERATOR_PREFIX + getOperationName();
-	}
-
-	public Object getOperationArgument() {
-		return new BasicDBObject();
-	}
-
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDbObject()
-	 */
-	@Override
-	public DBObject toDbObject() {
-		return new BasicDBObject(getOperationCommand(), getOperationArgument());
-	}
-
-	@Override
-	public String toString() {
-		return String.valueOf(toDbObject());
-	}
-}

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

@@ -1,63 +0,0 @@
-/*
- * 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;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-
-/**
- * @author Thomas Darimont
- */
-abstract class AbstractContextAwareAggregateOperation extends AbstractAggregateOperation implements
-		ContextConsumingAggregateOperation {
-
-	public AbstractContextAwareAggregateOperation(String operationName) {
-		super(operationName);
-	}
-
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#getOperationArgument()
-	 */
-	@Override
-	public Object getOperationArgument() {
-		throw new UnsupportedOperationException(String.format("This is not supported on an instance of %s",
-				ContextConsumingAggregateOperation.class.getName()));
-	}
-
-	/**
-	 * Creates the argument for the aggregation operation from the given {@code inputAggregateOperationContext}
-	 * 
-	 * @param inputAggregateOperationContext
-	 * @return the argument for the operation
-	 */
-	public abstract Object getOperationArgument(AggregateOperationContext inputAggregateOperationContext);
-
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#toDbObject()
-	 */
-	@Override
-	public DBObject toDbObject() {
-		throw new UnsupportedOperationException(String.format("This is not supported on an instance of %s",
-				ContextConsumingAggregateOperation.class.getName()));
-	}
-
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.aggregation.ContextAwareAggregateOperation#toDbObject(org.springframework.data.mongodb.core.aggregation.AggregateOperationContext)
-	 */
-	public DBObject toDbObject(AggregateOperationContext inputAggregateOperationContext) {
-		return new BasicDBObject(getOperationCommand(), getOperationArgument(inputAggregateOperationContext));
-	}
-}

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

@@ -1,39 +0,0 @@
-/*
- * 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
- */
-abstract class AbstractContextProducingAggregateOperation extends AbstractContextAwareAggregateOperation implements
-		ContextProducingAggregateOperation {
-
-	private final AggregateOperationContext outputAggregateOperationContext;
-
-	public AbstractContextProducingAggregateOperation(String operationName) {
-		super(operationName);
-		this.outputAggregateOperationContext = createAggregateContext();
-	}
-
-	private AggregateOperationContext createAggregateContext() {
-		return new BasicAggregateOperationContext();
-	}
-
-	public AggregateOperationContext getOutputAggregateOperationContext() {
-		return this.outputAggregateOperationContext;
-	}
-
-}

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

@@ -1,63 +0,0 @@
-/*
- * 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;
-
-import java.util.Map;
-
-/**
- * A {@code AggregateOperationContext} holds information about available fields for the aggregation steps.
- * 
- * @author Thomas Darimont
- */
-interface AggregateOperationContext {
-
-	Map<String, String> getAvailableFields();
-
-	/**
-	 * @param fieldName
-	 * @return the alias for the given fieldName if present in available fields. If the given field is not available the
-	 *         given fieldName is return instead.
-	 */
-	String returnFieldNameAliasIfAvailableOr(String fieldName);
-
-	/**
-	 * @param fieldName
-	 * @return true if the a field with the given field name is available.
-	 */
-	boolean isFieldAvailable(String fieldName);
-
-	/**
-	 * Registers a field with the given {@code fieldName} as available field.
-	 * 
-	 * @param fieldName
-	 */
-	void registerAvailableField(String fieldName);
-
-	/**
-	 * Registers a field with the given {@code fieldName} as field available with the given {@code availableFieldName} as
-	 * an alias.
-	 * 
-	 * @param fieldName
-	 */
-	void registerAvailableField(String fieldName, String availableFieldName);
-
-	/**
-	 * Removes the field with the given fieldName from the available fields.
-	 * 
-	 * @param fieldName
-	 */
-	void unregisterAvailableField(String fieldName);
-}

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

@@ -15,13 +15,19 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import static org.springframework.data.mongodb.core.aggregation.Fields.*;
+
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Direction;
+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.Fields.AggregationField;
 import org.springframework.data.mongodb.core.query.Criteria;
-import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.SerializationUtils;
 import org.springframework.util.Assert;
 
 import com.mongodb.BasicDBObject;
@@ -31,305 +37,249 @@ import com.mongodb.DBObject;
  * An {@code Aggregation} is a representation of a list of aggregation steps to be performed by the MongoDB Aggregation
  * Framework.
  * 
- * @author Tobias Trelle - Original API and Implementation
+ * @author Tobias Trelle
- * @author Thomas Darimont - Refactoring, embedded DSL
+ * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public class Aggregation<I, O> {
+public class Aggregation {
+
+	public static final AggregationOperationContext DEFAULT_CONTEXT = new NoOpAggregationOperationContext();
 
-	private final List<AggregationOperation> operations = new ArrayList<AggregationOperation>();
+	private final List<AggregationOperation> operations;
 
 	/**
 	 * Creates a new {@link Aggregation} from the given {@link AggregationOperation}s.
 	 * 
 	 * @param operations must not be {@literal null} or empty.
 	 */
-	public Aggregation(AggregationOperation... operations) {
+	public static Aggregation newAggregation(AggregationOperation... operations) {
-		registerOperations(operations);
+		return new Aggregation(operations);
-	}
-
-	private void registerOperations(AggregationOperation... operations) {
-
-		Assert.notNull(operations, "Operations must not be null!");
-		Assert.isTrue(operations.length > 0, "operations must not be empty!");
-		for (AggregationOperation operation : operations) {
-			Assert.notNull(operation, "Operation is not allowed to be null");
-			this.operations.add(operation);
-		}
 	}
 
 	/**
-	 * Converts this {@link Aggregation} specification to a {@link DBObject}.
+	 * Creates a new {@link TypedAggregation} for the given type and {@link AggregationOperation}s.
 	 * 
-	 * @param inputCollectionName the name of the input collection
+	 * @param type must not be {@literal null}.
-	 * @return the {@code DBObject} representing this aggregation
+	 * @param operations must not be {@literal null} or empty.
 	 */
-	public DBObject toDbObject(String inputCollectionName) {
+	public static <T> TypedAggregation<T> newAggregation(Class<T> type, AggregationOperation... operations) {
-
+		return new TypedAggregation<T>(type, operations);
-		DBObject command = new BasicDBObject("aggregate", inputCollectionName);
-		command.put("pipeline", getOperationObjects());
-		return command;
 	}
 
-	private List<DBObject> getOperationObjects() {
+	/**
-
+	 * Creates a new {@link Aggregation} from the given {@link AggregationOperation}s.
-		AggregateOperationContext aggregateOperationContext = createInitialAggregateOperationContext();
+	 * 
-		List<DBObject> operationObjects = new ArrayList<DBObject>();
+	 * @param aggregationOperations must not be {@literal null} or empty.
-		for (AggregationOperation operation : operations) {
+	 */
+	protected Aggregation(AggregationOperation... aggregationOperations) {
 
-			if (operation instanceof NoopAggreationOperation) {
+		Assert.notNull(aggregationOperations, "AggregationOperations must not be null!");
-				continue;
+		Assert.isTrue(aggregationOperations.length > 0, "At least one AggregationOperation has to be provided");
-			}
 
-			operationObjects.add(toOperationObject(operation, aggregateOperationContext));
+		this.operations = Arrays.asList(aggregationOperations);
-			if (operation instanceof ContextProducingAggregateOperation) {
-				aggregateOperationContext = ((ContextProducingAggregateOperation) operation)
-						.getOutputAggregateOperationContext();
-			}
-		}
-		return operationObjects;
 	}
 
 	/**
-	 * @param aggregateOperationContext
+	 * A pointer to the previous {@link AggregationOperation}.
-	 * @param operation
+	 * 
-	 * @return the {@link DBObject} representation of the given {@link AggregationOperation}
+	 * @return
 	 */
-	protected DBObject toOperationObject(AggregationOperation operation,
+	public static String previousOperation() {
-			AggregateOperationContext aggregateOperationContext) {
+		return "_id";
-
-		DBObject operationObject;
-		if (operation instanceof ContextConsumingAggregateOperation) {
-			operationObject = ((ContextConsumingAggregateOperation) operation).toDbObject(aggregateOperationContext);
-		} else {
-			operationObject = operation.toDbObject();
-		}
-		return operationObject;
-	}
-
-	protected AggregateOperationContext createInitialAggregateOperationContext() {
-		return new BasicAggregateOperationContext();
 	}
 
 	/**
-	 * Factory method to create a new {@link GroupOperation} for the given {@code idFields}.
+	 * Creates a new {@link ProjectionOperation} including the given fields.
 	 * 
-	 * @param idField the first idField to use, must not be {@literal null}.
+	 * @param fields must not be {@literal null}.
-	 * @param additionalIdFields more id fields to use, can be {@literal null}.
 	 * @return
 	 */
-	public static GroupOperation group(String idField, String... additionalIdFields) {
+	public static ProjectionOperation project(String... fields) {
-		return new GroupOperation(fields(idField, additionalIdFields));
+		return project(fields(fields));
 	}
 
 	/**
-	 * Factory method to create a new {@link GroupOperation} for the given {@code idFields}.
+	 * Creates a new {@link ProjectionOperation} includeing the given {@link Fields}.
 	 * 
-	 * @param idFields
+	 * @param fields must not be {@literal null}.
 	 * @return
 	 */
-	public static GroupOperation group(Fields idFields) {
+	public static ProjectionOperation project(Fields fields) {
-		return new GroupOperation(idFields);
+		return new ProjectionOperation(fields);
 	}
 
 	/**
-	 * Factory method to create a new {@link ProjectionOperation} for the given {@code fields}. The {@code _id} field is
+	 * Factory method to create a new {@link UnwindOperation} for the field with the given name.
-	 * implicitly excluded.
 	 * 
-	 * @param fields a list of fields to include in the projection.
+	 * @param fieldName must not be {@literal null} or empty.
-	 * @return The {@link ProjectionOperation}.
+	 * @return
 	 */
-	public static ProjectionOperation project(String... fields) {
+	public static UnwindOperation unwind(String field) {
-		return new ProjectionOperation(fields);
+		return new UnwindOperation(field(field));
 	}
 
 	/**
-	 * Factory method to create a new {@link ProjectionOperation}.
+	 * Creates a new {@link GroupOperation} for the given fields.
 	 * 
-	 * @return The {@link ProjectionOperation}.
+	 * @param fields must not be {@literal null}.
+	 * @return
 	 */
-	public static ProjectionOperation project() {
+	public static GroupOperation group(String... fields) {
-		return new ProjectionOperation();
+		return group(fields(fields));
 	}
 
 	/**
-	 * Factory method to create a new {@link ProjectionOperation} for the given {@code targetClass}.
+	 * Creates a new {@link GroupOperation} for the given {@link Fields}.
 	 * 
-	 * @param targetClass
+	 * @param fields must not be {@literal null}.
 	 * @return
 	 */
-	public static ProjectionOperation project(Class<?> targetClass) {
+	public static GroupOperation group(Fields fields) {
-		return new ProjectionOperation(targetClass);
+		return new GroupOperation(fields);
 	}
 
 	/**
-	 * Factory method to create a new {@link MatchOperation} for the given {@link Criteria}.
+	 * Factory method to create a new {@link SortOperation} for the given {@link Sort}.
 	 * 
-	 * @param criteria must not be {@literal null}
+	 * @param sort must not be {@literal null}.
 	 * @return
 	 */
-	public static MatchOperation match(Criteria criteria) {
+	public static SortOperation sort(Sort sort) {
-		return new MatchOperation(criteria);
+		return new SortOperation(sort);
 	}
 
 	/**
-	 * Factory method to create a new {@link UnwindOperation} for the given {@literal fieldName}.
+	 * Factory method to create a new {@link SortOperation} for the given sort {@link Direction} and {@code fields}.
 	 * 
-	 * @param fieldName {@link UnwindOperation}.
+	 * @param direction must not be {@literal null}.
+	 * @param fields must not be {@literal null}.
 	 * @return
 	 */
-	public static UnwindOperation unwind(String fieldName) {
+	public static SortOperation sort(Direction direction, String... fields) {
-		return new UnwindOperation(fieldName);
+		return new SortOperation(new Sort(direction, fields));
 	}
 
 	/**
-	 * Factory method to create a new {@link SkipOperation} for the given {@code skipCount}.
+	 * Creates a new {@link SkipOperation} skipping the given number of elements.
 	 * 
-	 * @param skipCount the number of documents to skip.
+	 * @param elementsToSkip must not be less than zero.
 	 * @return
 	 */
-	public static SkipOperation skip(int skipCount) {
+	public static SkipOperation skip(int elementsToSkip) {
-		return new SkipOperation(skipCount);
+		return new SkipOperation(elementsToSkip);
 	}
 
 	/**
-	 * Factory method to create a new {@link LimitOperation} for the given {@code maxElements}.
+	 * Creates a new {@link LimitOperation} limiting the result to the given number of elements.
 	 * 
-	 * @param maxElements, the max number of documents to return.
+	 * @param maxElements must not be less than zero.
 	 * @return
 	 */
-	public static LimitOperation limit(int maxElements) {
+	public static LimitOperation limit(long maxElements) {
 		return new LimitOperation(maxElements);
 	}
 
 	/**
-	 * Factory method to create a new {@link GeoNearOperation} for the given {@code nearQuery}.
+	 * Creates a new {@link MatchOperation} using the given {@link Criteria}.
 	 * 
-	 * @param nearQuery, must not be {@literal null}.
+	 * @param criteria must not be {@literal null}.
 	 * @return
 	 */
-	public static GeoNearOperation geoNear(NearQuery nearQuery) {
+	public static MatchOperation match(Criteria criteria) {
-		return new GeoNearOperation(nearQuery);
+		return new MatchOperation(criteria);
 	}
 
 	/**
-	 * Factory method to create a new {@link SortOperation} for the given sort {@link Direction}  {@code direction} and
+	 * Creates a new {@link Fields} instance for the given field names.
-	 * {@code fields}.
 	 * 
-	 * @param direction, the sort direction, must not be {@literal null}.
+	 * @see Fields#fields(String...)
 	 * @param fields must not be {@literal null}.
 	 * @return
 	 */
-	public static SortOperation sort(Sort.Direction direction, String... fields) {
+	public static Fields fields(String... fields) {
-		return sort(new Sort(direction, fields));
+		return Fields.fields(fields);
 	}
 
 	/**
-	 * Factory method to create a new {@link SortOperation} for the given {@link Sort}.
+	 * Creates a new {@link Fields} instance from the given field name and target reference.
 	 * 
-	 * @param sort
+	 * @param name must not be {@literal null} or empty.
+	 * @param target must not be {@literal null} or empty.
 	 * @return
 	 */
-	public static SortOperation sort(Sort sort) {
+	public static Fields bind(String name, String target) {
-		return new SortOperation(sort);
+		return Fields.from(field(name, target));
 	}
 
 	/**
-	 * Factory method to create a new {@link Fields} container for key-value pairs from the given {@code fieldNames}.
+	 * Converts this {@link Aggregation} specification to a {@link DBObject}.
-	 * <p>
-	 * A call to fields("a","b","c") generates:
-	 * <p>
-	 * 
-	 * <pre>
-	 * {    
-	 *   a: $a,
-	 *   b: $b,
-	 *   c: $c
-	 * }
-	 * </pre>
 	 * 
-	 * @return
+	 * @param inputCollectionName the name of the input collection
+	 * @return the {@code DBObject} representing this aggregation
 	 */
-	public static Fields fields(String fieldName, String... additionalFieldNames) {
+	public DBObject toDbObject(String inputCollectionName, AggregationOperationContext rootContext) {
-		return new BackendFields(additionalFieldNames).and(fieldName);
-	}
 
-	public static Fields fields() {
+		AggregationOperationContext context = rootContext;
-		return new BackendFields();
+		List<DBObject> operationDocuments = new ArrayList<DBObject>(operations.size());
-	}
 
-	public static Fields pick(String fieldName, Object fieldNameOrValue) {
+		for (AggregationOperation operation : operations) {
-		return fields().and(fieldName, fieldNameOrValue);
-	}
 
-	/**
+			operationDocuments.add(operation.toDBObject(context));
-	 * A convenience shortcut to {@link ReferenceUtil#$id()}
-	 * 
-	 * @return
-	 */
-	public static String $id() {
-		return ReferenceUtil.$id();
-	}
 
-	/**
+			if (operation instanceof AggregationOperationContext) {
-	 * A convenience shortcut to {@link ReferenceUtil#$(String)}
+				context = (AggregationOperationContext) operation;
-	 * 
+			}
-	 * @return
+		}
-	 */
-	public static String $(String fieldName) {
-		return ReferenceUtil.$(fieldName);
-	}
 
-	/**
+		DBObject command = new BasicDBObject("aggregate", inputCollectionName);
-	 * A convenience shortcut to {@link ReferenceUtil#$id(String)}
+		command.put("pipeline", operationDocuments);
-	 * 
-	 * @return
-	 */
-	public static String $id(String fieldName) {
-		return ReferenceUtil.$id(fieldName);
-	}
 
-	/**
+		return command;
-	 * A convenience shortcut to {@link ReferenceUtil#ID_KEY}
-	 * 
-	 * @return
-	 */
-	public static String id() {
-		return ReferenceUtil.ID_KEY;
 	}
 
-	/**
+	/* 
-	 * A convenience shortcut to {@link ReferenceUtil#id(String)}
+	 * (non-Javadoc)
-	 * 
+	 * @see java.lang.Object#toString()
-	 * @return
 	 */
-	public static String id(String fieldName) {
+	@Override
-		return ReferenceUtil.id(fieldName);
+	public String toString() {
+		return SerializationUtils
+				.serializeToJsonSafely(toDbObject("__collection__", new NoOpAggregationOperationContext()));
 	}
 
 	/**
-	 * Creates a new {@link Aggregation}.
+	 * Simple {@link AggregationOperationContext} that just returns {@link FieldReference}s as is.
 	 * 
-	 * @param <I> the input type of the {@link Aggregation}.
+	 * @author Oliver Gierke
-	 * @param <O> the output type of the {@link Aggregation}.
-	 * @param inputType
-	 * @param operations
-	 * @return
 	 */
-	public static <I, O> TypedAggregation<I, O> newAggregation(Class<I> inputType, AggregationOperation... operations) {
+	private static class NoOpAggregationOperationContext implements AggregationOperationContext {
-		return new TypedAggregation<I, O>(inputType, operations);
+
-	}
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getMappedObject(com.mongodb.DBObject)
+		 */
+		@Override
+		public DBObject getMappedObject(DBObject dbObject) {
+			return dbObject;
+		}
 
-	/**
+		/* 
-	 * Creates a new {@link Aggregation}.
+		 * (non-Javadoc)
-	 * 
+		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(org.springframework.data.mongodb.core.aggregation.ExposedFields.AvailableField)
-	 * @param <I> the input type of the {@link Aggregation}.
+		 */
-	 * @param <O> the output type of the {@link Aggregation}.
+		@Override
-	 * @param inputType
+		public FieldReference getReference(Field field) {
-	 * @param operations
+			return new FieldReference(new ExposedField(field, true));
-	 * @return
+		}
-	 */
-	public static <I, O> Aggregation<I, O> newAggregation(AggregationOperation... operations) {
-		return new Aggregation<I, O>(operations);
-	}
 
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
+		 */
+		@Override
+		public FieldReference getReference(String name) {
+			return new FieldReference(new ExposedField(new AggregationField(name), true));
+		}
+	}
 }

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

@@ -22,16 +22,16 @@ import com.mongodb.DBObject;
  * 
  * @author Sebastian Herold
  * @author Thomas Darimont
+ * @author Oliver Gierke
  * @since 1.3
  */
 public interface AggregationOperation {
 
-	String OPERATOR_PREFIX = "$";
-
 	/**
-	 * Creates a {@link DBObject} representation backing this object.
+	 * Turns the {@link AggregationOperation} into a {@link DBObject} by using the given
+	 * {@link AggregationOperationContext}.
 	 * 
 	 * @return the DBObject
 	 */
-	DBObject toDbObject();
+	DBObject toDBObject(AggregationOperationContext context);
 }

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

@@ -0,0 +1,55 @@
+/*
+ * 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;
+
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
+
+import com.mongodb.DBObject;
+
+/**
+ * The context for an {@link AggregationOperation}.
+ * 
+ * @author Oliver Gierke
+ * @since 1.3
+ */
+public interface AggregationOperationContext {
+
+	/**
+	 * Returns the mapped {@link DBObject}, potentially converting the source considering mapping metadata etc.
+	 * 
+	 * @param dbObject will never be {@literal null}.
+	 * @return must not be {@literal null}.
+	 */
+	DBObject getMappedObject(DBObject dbObject);
+
+	/**
+	 * Returns a {@link FieldReference} for the given field or {@literal null} if the context does not expose the given
+	 * field.
+	 * 
+	 * @param field must not be {@literal null}.
+	 * @return
+	 */
+	FieldReference getReference(Field field);
+
+	/**
+	 * Returns the {@link FieldReference} for the field with the given name or {@literal null} if the context does not
+	 * expose a field with the given name.
+	 * 
+	 * @param name must not be {@literal null} or empty.
+	 * @return
+	 */
+	FieldReference getReference(String name);
+}

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

@@ -58,10 +58,21 @@ public class AggregationResults<T> implements Iterable<T> {
 	 * 
 	 * @return
 	 */
-	public List<T> getAggregationResult() {
+	public List<T> getMappedResults() {
 		return mappedResults;
 	}
 
+	/**
+	 * Returns the unique mapped result. Assumes no result or exactly one.
+	 * 
+	 * @return
+	 * @throws IllegalArgumentException in case more than one result is available.
+	 */
+	public T getUniqueMappedResult() {
+		Assert.isTrue(mappedResults.size() < 2, "Expected unique result or null, but got more than one!");
+		return mappedResults.size() == 1 ? mappedResults.get(0) : null;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Iterable#iterator()

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

@@ -1,48 +0,0 @@
-package org.springframework.data.mongodb.core.aggregation;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Implementation of {@link Fields}
- * 
- * @author Thomas Darimont
- */
-class BackendFields implements Fields {
-
-	private Map<String, Object> values = new HashMap<String, Object>();
-
-	/**
-	 * @param names
-	 */
-	public BackendFields(String... names) {
-		for (String name : names) {
-			and(name);
-		}
-	}
-
-	/**
-	 * @param name
-	 * @return
-	 */
-	public Fields and(String name) {
-		return and(name, name);
-	}
-
-	/**
-	 * @param name
-	 * @param value
-	 * @return
-	 */
-	public Fields and(String name, Object value) {
-		this.values.put(name, value);
-		return this;
-	}
-
-	/**
-	 * @return
-	 */
-	public Map<String, Object> getValues() {
-		return new HashMap<String, Object>(this.values);
-	}
-}

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

@@ -1,62 +0,0 @@
-/*
- * 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;
-
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * Map based implementation of {@link AggregateOperationContext}.
- * 
- * @author Thomas Darimont
- */
-public class BasicAggregateOperationContext implements AggregateOperationContext {
-
-	private Map<String, String> availableFields = new LinkedHashMap<String, String>();
-
-	@Override
-	public Map<String, String> getAvailableFields() {
-		return new HashMap<String, String>(getAvailableFieldsInternal());
-	}
-
-	protected Map<String, String> getAvailableFieldsInternal() {
-		return this.availableFields;
-	}
-
-	@Override
-	public void registerAvailableField(String fieldName) {
-		registerAvailableField(fieldName, fieldName);
-	}
-
-	@Override
-	public void registerAvailableField(String fieldName, String availableFieldName) {
-		getAvailableFieldsInternal().put(fieldName, availableFieldName);
-	}
-
-	public String returnFieldNameAliasIfAvailableOr(String fieldName) {
-		return isFieldAvailable(fieldName) ? getAvailableFieldsInternal().get(fieldName) : fieldName;
-	}
-
-	public boolean isFieldAvailable(String fieldName) {
-		return getAvailableFieldsInternal().containsKey(ReferenceUtil.safeNonReference(fieldName));
-	}
-
-	@Override
-	public void unregisterAvailableField(String fieldName) {
-		getAvailableFieldsInternal().remove(fieldName);
-	}
-}

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

@@ -0,0 +1,286 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.util.Assert;
+import org.springframework.util.CompositeIterator;
+
+/**
+ * Value object to capture the fields exposed by an {@link AggregationOperation}.
+ * 
+ * @author Oliver Gierke
+ * @since 1.3
+ */
+public class ExposedFields implements Iterable<ExposedField> {
+
+	private static final List<ExposedField> NO_FIELDS = Collections.emptyList();
+	private static final ExposedFields EMPTY = new ExposedFields(NO_FIELDS, NO_FIELDS);
+
+	private final List<ExposedField> originalFields;
+	private final List<ExposedField> syntheticFields;
+
+	/**
+	 * Creates a new {@link ExposedFields} instance from the given {@link ExposedField}s.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	public static ExposedFields from(ExposedField... fields) {
+		return from(Arrays.asList(fields));
+	}
+
+	/**
+	 * Creates a new {@link ExposedFields} instance from the given {@link ExposedField}s.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	private static ExposedFields from(List<ExposedField> fields) {
+
+		ExposedFields result = EMPTY;
+
+		for (ExposedField field : fields) {
+			result = result.and(field);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Creates synthetic {@link ExposedFields} from the given {@link Fields}.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	public static ExposedFields synthetic(Fields fields) {
+		return createFields(fields, true);
+	}
+
+	/**
+	 * Creates non-synthetic {@link ExposedFields} from the given {@link Fields}.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	public static ExposedFields nonSynthetic(Fields fields) {
+		return createFields(fields, false);
+	}
+
+	/**
+	 * Creates a new {@link ExposedFields} instance for the given fields in either sythetic or non-synthetic way.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 * @param synthetic
+	 * @return
+	 */
+	private static ExposedFields createFields(Fields fields, boolean synthetic) {
+
+		Assert.notNull(fields, "Fields must not be null!");
+		List<ExposedField> result = new ArrayList<ExposedField>();
+
+		for (Field field : fields) {
+			result.add(new ExposedField(field, synthetic));
+		}
+
+		return ExposedFields.from(result);
+	}
+
+	/**
+	 * Creates a new {@link ExposedFields} with the given orignals and synthetics.
+	 * 
+	 * @param originals must not be {@literal null}.
+	 * @param synthetic must not be {@literal null}.
+	 */
+	private ExposedFields(List<ExposedField> originals, List<ExposedField> synthetic) {
+
+		this.originalFields = originals;
+		this.syntheticFields = synthetic;
+	}
+
+	/**
+	 * Creates a new {@link ExposedFields} adding the given {@link ExposedField}.
+	 * 
+	 * @param field must not be {@literal null}.
+	 * @return
+	 */
+	public ExposedFields and(ExposedField field) {
+
+		Assert.notNull(field, "Exposed field must not be null!");
+
+		ArrayList<ExposedField> result = new ArrayList<ExposedField>();
+		result.addAll(field.synthetic ? syntheticFields : originalFields);
+		result.add(field);
+
+		return new ExposedFields(field.synthetic ? originalFields : result, field.synthetic ? result : syntheticFields);
+	}
+
+	/**
+	 * Returns the field with the given name or {@literal null} if no field with the given name is available.
+	 * 
+	 * @param name
+	 * @return
+	 */
+	public ExposedField getField(String name) {
+
+		for (ExposedField field : this) {
+			if (field.canBeReferredToBy(name)) {
+				return field;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns whether the {@link ExposedFields} exposes a single field only.
+	 * 
+	 * @return
+	 */
+	public boolean exposesSingleFieldOnly() {
+		return originalFields.size() + syntheticFields.size() == 1;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see java.lang.Iterable#iterator()
+	 */
+	@Override
+	public Iterator<ExposedField> iterator() {
+
+		CompositeIterator<ExposedField> iterator = new CompositeIterator<ExposedField>();
+		iterator.add(syntheticFields.iterator());
+		iterator.add(originalFields.iterator());
+
+		return iterator;
+	}
+
+	/**
+	 * A single exposed field.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	static class ExposedField implements Field {
+
+		private final boolean synthetic;
+		private final Field field;
+
+		/**
+		 * Creates a new {@link ExposedField} with the given key.
+		 * 
+		 * @param key must not be {@literal null} or empty.
+		 * @param synthetic whether the exposed field is synthetic.
+		 */
+		public ExposedField(String key, boolean synthetic) {
+			this(Fields.field(key), synthetic);
+		}
+
+		/**
+		 * Creates a new {@link ExposedField} for the given {@link Field}.
+		 * 
+		 * @param delegate must not be {@literal null}.
+		 * @param synthetic whether the exposed field is synthetic.
+		 */
+		public ExposedField(Field delegate, boolean synthetic) {
+
+			this.field = delegate;
+			this.synthetic = synthetic;
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.Field#getKey()
+		 */
+		@Override
+		public String getName() {
+			return field.getName();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.Field#getTarget()
+		 */
+		@Override
+		public String getTarget() {
+			return field.getTarget();
+		}
+
+		/**
+		 * Returns whether the field can be referred to using the given name.
+		 * 
+		 * @param input
+		 * @return
+		 */
+		public boolean canBeReferredToBy(String input) {
+			return getTarget().equals(input);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see java.lang.Object#toString()
+		 */
+		@Override
+		public String toString() {
+			return String.format("AggregationField: %s, synthetic: %s", field, synthetic);
+		}
+	}
+
+	/**
+	 * A reference to an {@link ExposedField}.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	static class FieldReference {
+
+		private final ExposedField field;
+
+		/**
+		 * Creates a new {@link FieldReference} for the given {@link ExposedField}.
+		 * 
+		 * @param field must not be {@literal null}.
+		 */
+		public FieldReference(ExposedField field) {
+
+			Assert.notNull(field, "ExposedField must not be null!");
+			this.field = field;
+		}
+
+		/**
+		 * Returns the raw, unqualified reference, i.e. the field reference without a {@literal $} prefix.
+		 * 
+		 * @return
+		 */
+		public String getRaw() {
+			String target = field.getTarget();
+			return field.synthetic ? target : String.format("%s.%s", Fields.UNDERSCORE_ID, target);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see java.lang.Object#toString()
+		 */
+		@Override
+		public String toString() {
+			return String.format("$%s", getRaw());
+		}
+	}
+}

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

@@ -0,0 +1,67 @@
+/*
+ * 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;
+
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
+
+import com.mongodb.DBObject;
+
+/**
+ * Support class to implement {@link AggregationOperation}s that will become an {@link AggregationOperationContext} as
+ * well defining {@link ExposedFields}.
+ * 
+ * @author Oliver Gierke
+ * @since 1.3
+ */
+public abstract class ExposedFieldsAggregationOperationContext implements AggregationOperationContext {
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getMappedObject(com.mongodb.DBObject)
+	 */
+	@Override
+	public DBObject getMappedObject(DBObject dbObject) {
+		return dbObject;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(org.springframework.data.mongodb.core.aggregation.ExposedFields.AvailableField)
+	 */
+	@Override
+	public FieldReference getReference(Field field) {
+		return getReference(field.getName());
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
+	 */
+	@Override
+	public FieldReference getReference(String name) {
+
+		ExposedField field = getFields().getField(name);
+
+		if (field != null) {
+			return new FieldReference(field);
+		}
+
+		throw new IllegalArgumentException(String.format("Invalid reference '%s'!", name));
+	}
+
+	protected abstract ExposedFields getFields();
+}

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

@@ -15,17 +15,25 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-
 /**
- * Represents a skippable AggregationOperation that is not considered for execution.
+ * Abstraction for a field.
  * 
- * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public class NoopAggreationOperation implements AggregationOperation {
+public interface Field {
+
+	/**
+	 * Returns the name of the field.
+	 * 
+	 * @return must not be {@literal null}.
+	 */
+	String getName();
 
-	public DBObject toDbObject() {
+	/**
-		return new BasicDBObject();
+	 * Returns the target of the field. In case no explicit target is available {@link #getName()} should be returned.
-	}
+	 * 
+	 * @return must not be {@literal null}.
+	 */
+	String getTarget();
 }

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

@@ -15,17 +15,221 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
 /**
- * Fields is a collection of key-value pairs.
+ * Value object to capture a list of {@link Field} instances.
  * 
- * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public interface Fields {
+public class Fields implements Iterable<Field> {
-	Map<String, Object> getValues();
+
+	private static final String AMBIGUOUS_EXCEPTION = "Found two fields both using '%s' as name: %s and %s! Please "
+			+ "customize your field definitions to get to unique field names!";
+
+	public static String UNDERSCORE_ID = "_id";
+	public static String UNDERSCORE_ID_REF = "$_id";
+
+	private final List<Field> fields;
+
+	/**
+	 * Creates a new {@link Fields} instance from the given {@link Fields}.
+	 * 
+	 * @param fields must not be {@literal null} or empty.
+	 * @return
+	 */
+	public static Fields from(Field... fields) {
+
+		Assert.notNull(fields, "Fields must not be null!");
+		return new Fields(Arrays.asList(fields));
+	}
+
+	/**
+	 * Creates a new {@link Fields} instance for {@link Field}s with the given names.
+	 * 
+	 * @param names must not be {@literal null}.
+	 * @return
+	 */
+	public static Fields fields(String... names) {
+
+		Assert.notNull(names, "Field names must not be null!");
+
+		List<Field> fields = new ArrayList<Field>();
+
+		for (String name : names) {
+			fields.add(field(name));
+		}
+
+		return new Fields(fields);
+	}
+
+	/**
+	 * Creates a {@link Field} with the given name.
+	 * 
+	 * @param name must not be {@literal null} or empty.
+	 * @return
+	 */
+	public static Field field(String name) {
+		return new AggregationField(name);
+	}
+
+	public static Field field(String name, String target) {
+		Assert.hasText(target, "Target must not be null or empty!");
+		return new AggregationField(name, target);
+	}
+
+	/**
+	 * Creates a new {@link Fields} instance using the given {@link Field}s.
+	 * 
+	 * @param fields must not be {@literal null}.
+	 */
+	private Fields(List<Field> fields) {
+
+		Assert.notNull(fields, "Fields must not be null!");
+
+		this.fields = verify(fields);
+	}
+
+	private static final List<Field> verify(List<Field> fields) {
+
+		Map<String, Field> reference = new HashMap<String, Field>();
+
+		for (Field field : fields) {
+
+			String name = field.getName();
+			Field found = reference.get(name);
+
+			if (found != null) {
+				throw new IllegalArgumentException(String.format(AMBIGUOUS_EXCEPTION, name, found, field));
+			}
+
+			reference.put(name, field);
+		}
+
+		return fields;
+	}
+
+	private Fields(Fields existing, Field tail) {
+
+		this.fields = new ArrayList<Field>(existing.fields.size() + 1);
+		this.fields.addAll(existing.fields);
+		this.fields.add(tail);
+	}
+
+	/**
+	 * Creates a new {@link Fields} instance with a new {@link Field} of the given name added.
+	 * 
+	 * @param name must not be {@literal null}.
+	 * @return
+	 */
+	public Fields and(String name) {
+		return and(new AggregationField(name));
+	}
+
+	public Fields and(String name, String target) {
+		return and(new AggregationField(name, target));
+	}
+
+	public Fields and(Field field) {
+		return new Fields(this, field);
+	}
+
+	public Fields and(Fields fields) {
+
+		Fields result = this;
+
+		for (Field field : fields) {
+			result = result.and(field);
+		}
+
+		return result;
+	}
+
+	public Field getField(String name) {
+
+		for (Field field : fields) {
+			if (field.getName().equals(name)) {
+				return field;
+			}
+		}
+
+		return null;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see java.lang.Iterable#iterator()
+	 */
+	@Override
+	public Iterator<Field> iterator() {
+		return fields.iterator();
+	}
+
+	/**
+	 * Value object to encapsulate a field in an aggregation operation.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	static class AggregationField implements Field {
+
+		private final String name;
+		private final String target;
+
+		/**
+		 * Creates an aggregation fieldwith the given name. As no target is set explicitly, the name will be used as target
+		 * as well.
+		 * 
+		 * @param key
+		 */
+		public AggregationField(String key) {
+			this(key, null);
+		}
+
+		public AggregationField(String name, String target) {
+
+			Assert.hasText(name, "AggregationField name must not be null or empty!");
+
+			if (target == null && name.contains(".")) {
+				this.name = name.substring(name.indexOf(".") + 1);
+				this.target = name;
+			} else {
+				this.name = name;
+				this.target = target;
+			}
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.Field#getKey()
+		 */
+		public String getName() {
+			return name;
+		}
 
-	Fields and(String name);
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.Field#getAlias()
+		 */
+		public String getTarget() {
+			return StringUtils.hasText(this.target) ? this.target : this.name;
+		}
 
-	Fields and(String name, Object value);
+		/* 
+		 * (non-Javadoc)
+		 * @see java.lang.Object#toString()
+		 */
+		@Override
+		public String toString() {
+			return String.format("AggregationField - name: %s, target: %s", name, target);
+		}
+	}
 }

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

@@ -18,21 +18,29 @@ package org.springframework.data.mongodb.core.aggregation;
 import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.util.Assert;
 
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
 /**
  * @author Thomas Darimont
+ * @since 1.3
  */
-public class GeoNearOperation extends AbstractAggregateOperation {
+public class GeoNearOperation implements AggregationOperation {
 
 	private final NearQuery nearQuery;
 
 	public GeoNearOperation(NearQuery nearQuery) {
-		super("geoNear");
+
 		Assert.notNull(nearQuery);
 		this.nearQuery = nearQuery;
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
 	@Override
-	public Object getOperationArgument() {
+	public DBObject toDBObject(AggregationOperationContext context) {
-		return nearQuery.toDBObject();
+		return new BasicDBObject("$geoNear", context.getMappedObject(nearQuery.toDBObject()));
 	}
 }

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

@@ -17,9 +17,12 @@ package org.springframework.data.mongodb.core.aggregation;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.Locale;
 
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
 import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
 
 import com.mongodb.BasicDBObject;
 import com.mongodb.DBObject;
@@ -30,392 +33,232 @@ import com.mongodb.DBObject;
  * @see http://docs.mongodb.org/manual/reference/aggregation/group/#stage._S_group
  * @author Sebastian Herold
  * @author Thomas Darimont
+ * @author Oliver Gierke
  * @since 1.3
  */
-public class GroupOperation extends AbstractContextProducingAggregateOperation {
+public class GroupOperation extends ExposedFieldsAggregationOperationContext implements AggregationOperation {
 
-	final Object id;
+	private final ExposedFields nonSynthecticFields;
-	final List<GroupingOperation> ops = new ArrayList<GroupOperation.GroupingOperation>();
+	private final List<Operation> operations;
 
 	/**
-	 * Creates a <code>$group</code> operation with <code>_id</code> referencing to a field of the document. The returned
+	 * Creates a new {@link GroupOperation} including the given {@link Fields}.
-	 * db object equals to
 	 * 
-	 * <pre>
+	 * @param fields must not be {@literal null}.
-	 * {_id: "$field"}
-	 * </pre>
-	 * 
-	 * @param id
-	 * @param moreIdFields
 	 */
 	public GroupOperation(Fields fields) {
-		super("group");
+
-		this.id = createGroupIdFrom(fields);
+		this.nonSynthecticFields = ExposedFields.nonSynthetic(fields);
+		this.operations = new ArrayList<Operation>();
 	}
 
 	/**
-	 * @param fields
+	 * Creates a new {@link GroupOperation} from the given {@link GroupOperation} and the given {@link Operation}.
+	 * 
+	 * @param current must not be {@literal null}.
+	 * @param operation must not be {@literal null}.
+	 */
+	protected GroupOperation(GroupOperation current, Operation operation) {
+
+		Assert.notNull(current, "GroupOperation must not be null!");
+		Assert.notNull(operation, "Operation must not be null!");
+
+		this.nonSynthecticFields = current.nonSynthecticFields;
+		this.operations = new ArrayList<Operation>(current.operations.size() + 1);
+		this.operations.addAll(current.operations);
+		this.operations.add(operation);
+	}
+
+	/**
+	 * Creates a new {@link GroupOperation} from the current one adding the given {@link Operation}.
+	 * 
+	 * @param operation must not be {@literal null}.
 	 * @return
 	 */
-	private Object createGroupIdFrom(Fields fields) {
+	protected GroupOperation and(Operation operation) {
-
+		return new GroupOperation(this, operation);
-		Assert.notNull(fields, "fields must not be null!");
-		Map<String, Object> values = fields.getValues();
-		Assert.notEmpty(values, "fields.values must not be empty!");
-
-		DBObject idReferences = new BasicDBObject(values.size());
-		for (Map.Entry<String, Object> entry : values.entrySet()) {
-			String idFieldName = ReferenceUtil.safeNonReference(entry.getKey());
-			Object idFieldValue = entry.getValue() instanceof String ? ReferenceUtil.safeReference(entry.getValue()
-					.toString()) : entry.getValue();
-			idReferences.put(idFieldName, idFieldValue);
-		}
-		return idReferences;
 	}
 
-	/* (non-Javadoc)
+	/**
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#getOperationArgument()
+	 * Returns a {@link GroupOperationBuilder} to build a grouping operation for the field with the given name
+	 * 
+	 * @param field must not be {@literal null} or empty.
+	 * @return
 	 */
-	@Override
+	public GroupOperationBuilder and(String field) {
-	public Object getOperationArgument(AggregateOperationContext inputAggregateOperationContext) {
+		return new GroupOperationBuilder(field, this);
+	}
+
+	public class GroupOperationBuilder {
+
+		private final String name;
+		private final GroupOperation current;
+
+		public GroupOperationBuilder(String name, GroupOperation current) {
 
-		DBObject projection = new BasicDBObject();
+			Assert.hasText(name, "Field name must not be null or empty!");
+			Assert.notNull(current, "GroupOperation must not be null!");
 
-		Object idToUse = id;
+			this.name = name;
-		if (idToUse instanceof DBObject) {
+			this.current = current;
-			idToUse = createGroupIdObject((DBObject) idToUse, inputAggregateOperationContext);
 		}
-		projection.put(ReferenceUtil.ID_KEY, idToUse);
 
-		for (GroupingOperation op : ops) {
+		public GroupOperation count() {
-			projection.put(op.alias, op.toDbObject(inputAggregateOperationContext));
+			return sum(1);
 		}
 
-		return projection;
+		public GroupOperation count(String reference) {
-	}
+			return sum(reference, 1);
+		}
 
-	/**
+		public GroupOperation sum() {
-	 * @param idCandidate
+			return sum(name);
-	 * @param inputAggregateOperationContext
+		}
-	 * @return
-	 */
-	private Object createGroupIdObject(DBObject groupIdObject, AggregateOperationContext inputAggregateOperationContext) {
 
-		Object simpleIdOrNull = returnIfGroupIdIsSingleFieldReference(inputAggregateOperationContext, groupIdObject);
+		public GroupOperation sum(String reference) {
-		if (simpleIdOrNull != null) {
+			return sum(reference, null);
-			return simpleIdOrNull;
 		}
 
-		DBObject idObject = new BasicDBObject();
+		public GroupOperation sum(Object value) {
-		for (String idFieldName : groupIdObject.keySet()) {
+			return sum(null, value);
+		}
 
-			Object idFieldValue = groupIdObject.get(idFieldName);
+		public GroupOperation sum(String reference, Object value) {
-			Object idFieldValueOrNull = returnIfFieldValueReferencesAvailableField(inputAggregateOperationContext,
+			return current.and(new Operation(GroupOps.SUM, name, reference, value));
-					idFieldName, idFieldValue);
+		}
-			if (idFieldValueOrNull != null) {
-				idFieldValue = idFieldValueOrNull;
-			}
 
-			getOutputAggregateOperationContext().registerAvailableField(idFieldName, ReferenceUtil.id(idFieldName));
+		public GroupOperation addToSet() {
-			idObject.put(idFieldName, idFieldValue);
+			return addToSet(null);
 		}
 
-		return idObject;
+		public GroupOperation addToSet(String reference) {
-	}
+			return current.and(new Operation(GroupOps.ADD_TO_SET, name, reference, null));
+		}
 
-	private Object returnIfGroupIdIsSingleFieldReference(AggregateOperationContext inputAggregateOperationContext,
+		public GroupOperation last() {
-			DBObject idObject) {
+			return last(null);
+		}
 
-		if (idObject.keySet().size() != 1) {
+		public GroupOperation last(String reference) {
-			return null;
+			return current.and(new Operation(GroupOps.LAST, name, reference, null));
 		}
 
-		return returnIfFieldNameIsSimpleReference(inputAggregateOperationContext, idObject, idObject.keySet().iterator()
+		public GroupOperation first() {
-				.next());
+			return first(null);
-	}
+		}
 
-	private Object returnIfFieldValueReferencesAvailableField(AggregateOperationContext inputAggregateOperationContext,
+		public GroupOperation first(String reference) {
-			String idFieldName, Object idFieldValue) {
+			return current.and(new Operation(GroupOps.FIRST, name, reference, null));
+		}
 
-		Assert.notNull(inputAggregateOperationContext, "inputAggregateOperationContext must not be null");
+		public GroupOperation avg() {
+			return avg(null);
+		}
 
-		if (!ReferenceUtil.isValueFieldReference(idFieldName, idFieldValue)) {
+		public GroupOperation avg(String reference) {
-			return null;
+			return current.and(new Operation(GroupOps.AVG, name, reference, null));
 		}
+	}
 
-		if (!inputAggregateOperationContext.isFieldAvailable(idFieldName)) {
+	/* 
-			return null;
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getFields()
+	 */
+	@Override
+	public ExposedFields getFields() {
+
+		ExposedFields fields = this.nonSynthecticFields.and(new ExposedField(Fields.UNDERSCORE_ID, true));
+
+		for (Operation operation : operations) {
+			fields = fields.and(operation.asField());
 		}
 
-		String idFieldNameToUse = inputAggregateOperationContext.returnFieldNameAliasIfAvailableOr(idFieldName);
+		return fields;
-		return ReferenceUtil.safeReference(inputAggregateOperationContext instanceof GroupOperation ? ReferenceUtil
-				.id(idFieldNameToUse) : idFieldNameToUse);
 	}
 
-	private Object returnIfFieldNameIsSimpleReference(AggregateOperationContext inputAggregateOperationContext,
+	/*
-			DBObject idObject, String idFieldName) {
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
+	@Override
+	public com.mongodb.DBObject toDBObject(AggregationOperationContext context) {
 
-		Object idFieldValue = idObject.get(idFieldName);
+		BasicDBObject operationObject = new BasicDBObject();
 
-		if (!idFieldValueIsSimpleIdFieldExpression(idFieldName, idFieldValue)) {
+		if (nonSynthecticFields.exposesSingleFieldOnly()) {
-			return null;
-		}
 
-		getOutputAggregateOperationContext().registerAvailableField(idFieldName, ReferenceUtil.id(idFieldName));
+			FieldReference reference = context.getReference(nonSynthecticFields.iterator().next());
-		idFieldValue = ReferenceUtil.safeReference(inputAggregateOperationContext
+			operationObject.put(Fields.UNDERSCORE_ID, reference.toString());
-				.returnFieldNameAliasIfAvailableOr(idFieldName));
 
-		return idFieldValue;
+		} else {
-	}
 
-	private static boolean idFieldValueIsSimpleIdFieldExpression(String idFieldName, Object idFieldValue) {
+			BasicDBObject inner = new BasicDBObject();
-		return idFieldValue instanceof String
-				&& idFieldName.equals(ReferenceUtil.safeNonReference(idFieldValue.toString()));
-	}
 
-	/**
+			for (ExposedField field : nonSynthecticFields) {
-	 * Adds a field with the <a
+				FieldReference reference = context.getReference(field);
-	 * href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_addToSet">$addToSet operation</a>.
+				inner.put(field.getName(), reference.toString());
-	 * 
+			}
-	 * <pre>
-	 * { $group : {
-	 *      _id : "$id_field",
-	 *     name : { $addToSet : "$field" }
-	 * }}
-	 * </pre>
-	 * 
-	 * @see http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_addToSet
-	 * @param name key of the field.
-	 * @param field reference to a field of the document.
-	 * @return
-	 */
-	public GroupOperation addToSet(String name, String field) {
-		return addOperation("$addToSet", name, field);
-	}
 
-	/**
+			operationObject.put(Fields.UNDERSCORE_ID, inner);
-	 * Adds a field with the {@code $first} operation.
+		}
-	 * 
-	 * <pre>
-	 * { $group : {
-	 *      _id : "$id_field",
-	 *     name : { $first : "$field" }
-	 * }}
-	 * </pre>
-	 * 
-	 * @see http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_first
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation first(String name, String field) {
-		return addOperation("$first", name, field);
-	}
 
-	/**
+		for (Operation operation : operations) {
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_last">$last
+			operationObject.putAll(operation.toDBObject(context));
-	 * operation</a>.
+		}
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$last: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation last(String name, String field) {
-		return addOperation("$last", name, field);
-	}
 
-	/**
+		return new BasicDBObject("$group", operationObject);
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_max">$max
-	 * operation</a>.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$max: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation max(String name, String field) {
-		return addOperation("$max", name, field);
 	}
 
-	/**
+	interface Keyword {
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_min">$min
-	 * operation</a>.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$min: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation min(String name, String field) {
-		return addOperation("$min", name, field);
-	}
 
-	/**
+		String toString();
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_avg">$avg
-	 * operation</a>.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$avg: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation avg(String name, String field) {
-		return addOperation("$avg", name, field);
 	}
 
-	/**
+	private static enum GroupOps implements Keyword {
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_push">$push
-	 * operation</a>.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$push: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation push(String name, String field) {
-		return addOperation("$push", name, field);
-	}
 
-	/**
+		SUM, LAST, FIRST, PUSH, AVG, MIN, MAX, ADD_TO_SET, COUNT;
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_sum">$sum
-	 * operation</a> with a constant value.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$sum: increment}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param increment increment for each item
-	 * @return
-	 */
-	public GroupOperation count(String name, double increment) {
-		return sum(name, increment);
-	}
 
-	/**
+		@Override
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_sum">$sum
+		public String toString() {
-	 * operation</a> count every item.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$sum: 1}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @return
-	 */
-	public GroupOperation count(String name) {
-		return count(name, 1);
-	}
 
-	private GroupOperation sum(String name, Object field) {
+			String[] parts = name().split("_");
-		return addOperation("$sum", name, field);
-	}
 
-	/**
+			StringBuilder builder = new StringBuilder();
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_sum">$sum
-	 * operation</a>.
-	 * 
-	 * <pre>
-	 *     {$group: {
-	 *          _id: "$id_field",
-	 *          name: {$sum: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param name key of the field
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation sum(String name, String field) {
-		return sum(name, (Object) field);
-	}
 
-	/**
+			for (String part : parts) {
-	 * Adds a field with the <a href="http://docs.mongodb.org/manual/reference/aggregation/addToSet/#grp._S_sum">$sum
+				String lowerCase = part.toLowerCase(Locale.US);
-	 * operation</a>.
+				builder.append(builder.length() == 0 ? lowerCase : StringUtils.capitalize(lowerCase));
-	 * 
+			}
-	 * <pre>
+
-	 *     {$group: {
+			return "$" + builder.toString();
-	 *          _id: "$id_field",
+		}
-	 *          field: {$sum: "$field"}
-	 *     }}
-	 * </pre>
-	 * 
-	 * @param field reference to a field of the document
-	 * @return
-	 */
-	public GroupOperation sum(String field) {
-		return sum(field, field);
 	}
 
-	protected GroupOperation addOperation(String operation, String name, Object field) {
+	static class Operation implements AggregationOperation {
 
-		getOutputAggregateOperationContext().registerAvailableField(name);
+		private final Keyword op;
-		this.ops.add(new GroupingOperation(operation, name, field));
+		private final String key;
-		return this;
+		private final String reference;
-	}
+		private final Object value;
 
-	static class GroupingOperation {
+		public Operation(Keyword op, String key, String reference, Object value) {
-		final String operation;
-		final String alias;
-		final Object fieldNameOrValue;
 
-		public GroupingOperation(String operation, String alias, Object fieldNameOrValue) {
+			this.op = op;
-			this.operation = operation;
+			this.key = key;
-			this.alias = alias;
+			this.reference = reference;
-			this.fieldNameOrValue = fieldNameOrValue;
+			this.value = value;
 		}
 
-		public DBObject toDbObject(AggregateOperationContext inputAggregateOperationContext) {
+		public ExposedField asField() {
-
+			return new ExposedField(key, true);
-			Object fieldNameOrValueToUse = fieldNameOrValue;
+		}
 
-			if (fieldNameOrValue instanceof String) {
+		public DBObject toDBObject(AggregationOperationContext context) {
-				if (inputAggregateOperationContext != null) {
+			return new BasicDBObject(key, new BasicDBObject(op.toString(), getValue(context)));
-					fieldNameOrValueToUse = inputAggregateOperationContext
+		}
-							.returnFieldNameAliasIfAvailableOr((String) fieldNameOrValueToUse);
-				}
-				fieldNameOrValueToUse = ReferenceUtil.safeReference((String) fieldNameOrValueToUse);
-			}
 
-			return new BasicDBObject(operation, fieldNameOrValueToUse);
+		public Object getValue(AggregationOperationContext context) {
+			return reference == null ? value : context.getReference(reference).toString();
 		}
 	}
 }

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

@@ -15,13 +15,20 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import org.springframework.util.Assert;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
 /**
  * Encapsulates the {@code $limit}-operation
  * 
  * @see http://docs.mongodb.org/manual/reference/aggregation/limit/
  * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-class LimitOperation extends AbstractAggregateOperation {
+class LimitOperation implements AggregationOperation {
 
 	private final long maxElements;
 
@@ -29,12 +36,17 @@ class LimitOperation extends AbstractAggregateOperation {
 	 * @param maxElements Number of documents to consider.
 	 */
 	public LimitOperation(long maxElements) {
-		super("limit");
+
+		Assert.isTrue(maxElements >= 0, "Maximum number of elements must be greater or equal to zero!");
 		this.maxElements = maxElements;
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
 	@Override
-	public Object getOperationArgument() {
+	public DBObject toDBObject(AggregationOperationContext context) {
-		return maxElements;
+		return new BasicDBObject("$limit", maxElements);
 	}
 }

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

@@ -18,6 +18,7 @@ package org.springframework.data.mongodb.core.aggregation;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.util.Assert;
 
+import com.mongodb.BasicDBObject;
 import com.mongodb.DBObject;
 
 /**
@@ -26,10 +27,12 @@ import com.mongodb.DBObject;
  * @see http://docs.mongodb.org/manual/reference/aggregation/match/
  * @author Sebastian Herold
  * @author Thomas Darimont
+ * @author Oliver Gierke
  * @since 1.3
  */
-public class MatchOperation extends AbstractAggregateOperation {
+public class MatchOperation implements AggregationOperation {
-	private final DBObject criteria;
+
+	private final Criteria criteria;
 
 	/**
 	 * Creates a new {@link MatchOperation} for the given {@link Criteria}.
@@ -38,16 +41,16 @@ public class MatchOperation extends AbstractAggregateOperation {
 	 */
 	public MatchOperation(Criteria criteria) {
 
-		super("match");
 		Assert.notNull(criteria, "Criteria must not be null!");
-		this.criteria = criteria.getCriteriaObject();
+		this.criteria = criteria;
 	}
 
-	/* (non-Javadoc)
+	/* 
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#getOperationArgument()
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
 	 */
 	@Override
-	public Object getOperationArgument() {
+	public DBObject toDBObject(AggregationOperationContext context) {
-		return criteria;
+		return new BasicDBObject("$match", context.getMappedObject(criteria.getCriteriaObject()));
 	}
 }

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

@@ -16,268 +16,386 @@
 package org.springframework.data.mongodb.core.aggregation;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.EmptyStackException;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Stack;
 
-import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
-import org.springframework.data.mongodb.core.query.Field;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
+import org.springframework.data.mongodb.core.aggregation.ProjectionOperation.ProjectionOperationBuilder.FieldProjection;
 import org.springframework.util.Assert;
 
 import com.mongodb.BasicDBObject;
 import com.mongodb.DBObject;
 
 /**
- * Encapsulates the aggregation framework {@code $project}-operation.
+ * Encapsulates the aggregation framework {@code $project}-operation. Projection of field to be used in an
- * <p>
+ * {@link Aggregation}. A projection is similar to a {@link Field} inclusion/exclusion but more powerful. It can
- * Projection of field to be used in an {@link Aggregation}. A projection is similar to a {@link Field}
+ * generate new fields, change values of given field etc.
- * inclusion/exclusion but more powerful. It can generate new fields, change values of given field etc.
  * <p>
  * 
  * @see http://docs.mongodb.org/manual/reference/aggregation/project/
  * @author Tobias Trelle
  * @author Thomas Darimont
+ * @author Oliver Gierke
  * @since 1.3
  */
-public class ProjectionOperation extends AbstractContextProducingAggregateOperation {
+public class ProjectionOperation extends ExposedFieldsAggregationOperationContext implements AggregationOperation {
 
-	/** Stack of key names. Size is 0 or 1. */
+	private static final List<Projection> NONE = Collections.emptyList();
-	private final Stack<String> reference = new Stack<String>();
-	private final Map<String, Object> projection = new HashMap<String, Object>();
 
-	private DBObject rightHandExpression;
+	private final List<Projection> projections;
 
-	/**
+	public ProjectionOperation() {
-	 * This convenience constructor excludes the field {@code _id} and includes the given fields.
+		this(NONE, NONE);
-	 * 
+	}
-	 * @param includes Keys of field to include, must not be {@literal null} or empty.
-	 */
-	public ProjectionOperation(String... includes) {
 
-		super("project");
+	public ProjectionOperation(Fields fields) {
+		this(NONE, ProjectionOperationBuilder.FieldProjection.from(fields, true));
+	}
 
-		Assert.notNull(includes, "includes must not be null");
+	private ProjectionOperation(List<? extends Projection> current, List<? extends Projection> projections) {
-		exclude("_id");
 
-		for (String key : includes) {
+		this.projections = new ArrayList<ProjectionOperation.Projection>(current.size() + projections.size());
-			include(key);
+		this.projections.addAll(current);
-		}
+		this.projections.addAll(projections);
+	}
+
+	protected ProjectionOperation and(Projection projection) {
+		return new ProjectionOperation(this.projections, Arrays.asList(projection));
 	}
 
 	/**
-	 * Create an empty projection.
+	 * Creates a new {@link ProjectionOperationBuilder} to define a projection for the field with the given name.
 	 * 
-	 * @param targetClass
+	 * @param name must not be {@literal null} or empty.
+	 * @return
 	 */
-	public ProjectionOperation(Class<?> targetClass) {
+	public ProjectionOperationBuilder and(String name) {
-		this(extractFieldsFrom(targetClass));
+		return new ProjectionOperationBuilder(name, this);
 	}
 
 	/**
-	 * @param targetClass
+	 * Excludes the given fields from the projection.
+	 * 
+	 * @param fields must not be {@literal null}.
 	 * @return
 	 */
-	private static String[] extractFieldsFrom(Class<?> targetClass) {
+	public ProjectionOperation andExclude(String... fields) {
-		return new String[0];
+		List<FieldProjection> excludeProjections = FieldProjection.from(Fields.fields(fields), false);
+		return new ProjectionOperation(this.projections, excludeProjections);
 	}
 
 	/**
-	 * Excludes a given field.
+	 * Includes the given fields into the projection.
 	 * 
-	 * @param key The key of the field.
+	 * @param fields must not be {@literal null}.
+	 * @return
 	 */
-	public final ProjectionOperation exclude(String key) {
+	public ProjectionOperation andInclude(String... fields) {
-
-		Assert.hasText(key, "Missing key");
-		getOutputAggregateOperationContext().unregisterAvailableField(ReferenceUtil.safeNonReference(key));
 
-		projection.put(key, 0);
+		List<FieldProjection> projections = FieldProjection.from(Fields.fields(fields), true);
-		return this;
+		return new ProjectionOperation(this.projections, projections);
 	}
 
 	/**
-	 * Includes a given field.
+	 * Includes the given fields into the projection.
 	 * 
-	 * @param key The key of the field, must not be {@literal null} or empty.
+	 * @param fields must not be {@literal null}.
+	 * @return
+	 */
+	public ProjectionOperation andInclude(Fields fields) {
+		return new ProjectionOperation(this.projections, FieldProjection.from(fields, true));
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.ExposedFieldsAggregationOperationContext#getFields()
 	 */
-	public final ProjectionOperation include(String key) {
+	@Override
+	protected ExposedFields getFields() {
 
-		Assert.hasText(key, "Missing key");
+		ExposedFields fields = null;
 
-		safePop();
+		for (Projection projection : projections) {
-		reference.push(key);
+			ExposedField field = projection.getField();
-		getOutputAggregateOperationContext().registerAvailableField(key);
+			fields = fields == null ? ExposedFields.from(field) : fields.and(field);
+		}
 
-		return this;
+		return fields;
 	}
 
-	/**
+	/*
-	 * Sets the key for a computed field.
+	 * (non-Javadoc)
-	 * 
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
-	 * @param key must not be {@literal null} or empty.
 	 */
-	public final ProjectionOperation as(String key) {
+	@Override
+	public DBObject toDBObject(AggregationOperationContext context) {
 
-		Assert.hasText(key, "Missing key");
+		BasicDBObject fieldObject = new BasicDBObject();
 
-		try {
+		for (Projection projection : projections) {
-			String rhsFieldName = reference.pop();
+			fieldObject.putAll(projection.toDBObject(context));
-			getOutputAggregateOperationContext().unregisterAvailableField(ReferenceUtil.safeNonReference(rhsFieldName));
-			getOutputAggregateOperationContext().registerAvailableField(ReferenceUtil.safeNonReference(key));
-			projection.put(key, rightHandSide(ReferenceUtil.safeReference(rhsFieldName)));
-		} catch (EmptyStackException e) {
-			throw new InvalidDataAccessApiUsageException("Invalid use of as()", e);
 		}
 
-		return this;
+		return new BasicDBObject("$project", fieldObject);
 	}
 
 	/**
-	 * Sets the key for a computed field.
+	 * Builder for {@link ProjectionOperation}s on a field.
 	 * 
-	 * @param key must not be {@literal null} or empty.
+	 * @author Oliver Gierke
 	 */
-	public final ProjectionOperation asSelf() {
+	public static class ProjectionOperationBuilder {
 
-		try {
+		private final String name;
-			String selfRef = reference.pop();
+		private final ProjectionOperation operation;
-			projection.put(selfRef, rightHandSide(ReferenceUtil.safeReference(selfRef)));
-		} catch (EmptyStackException e) {
-			throw new InvalidDataAccessApiUsageException("Invalid use of as()", e);
-		}
 
-		return this;
+		/**
-	}
+		 * 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}.
+		 */
+		public ProjectionOperationBuilder(String name, ProjectionOperation operation) {
 
-	public final ProjectionOperation plus(Number n) {
+			Assert.hasText(name, "Field name must not be null or empty!");
-		return arithmeticOperation("add", n);
+			Assert.notNull(operation, "ProjectionOperation must not be null!");
-	}
 
-	public final ProjectionOperation minus(Number n) {
+			this.name = name;
-		return arithmeticOperation("substract", n);
+			this.operation = operation;
-	}
+		}
 
-	private ProjectionOperation arithmeticOperation(String op, Number n) {
+		/**
+		 * Projects the result of the previous operation onto the current field. Will automatically add an exclusion for
+		 * {@code _id} as what would be held in it by default will now go into the field just projected into.
+		 * 
+		 * @return
+		 */
+		public ProjectionOperation previousOperation() {
 
-		Assert.notNull(n, "Missing number");
+			return this.operation.andExclude(Fields.UNDERSCORE_ID) //
-		rightHandExpression = createArrayObject(op, ReferenceUtil.safeReference(reference.peek()), n);
+					.and(new PreviousOperationProjection(name));
-		return this;
+		}
-	}
 
-	private DBObject createArrayObject(String op, Object... items) {
+		/**
+		 * Defines a nested field binding for the current field.
+		 * 
+		 * @param fields must not be {@literal null}.
+		 * @return
+		 */
+		public ProjectionOperation nested(Fields fields) {
+			return this.operation.and(new NestedFieldProjection(name, fields));
+		}
 
-		List<Object> list = new ArrayList<Object>();
+		public ProjectionOperation plus(Number number) {
-		Collections.addAll(list, items);
+			Assert.notNull(number, "Number must not be null!");
+			return project("add", number);
+		}
 
-		return new BasicDBObject(ReferenceUtil.safeReference(op), list);
+		public ProjectionOperation minus(Number number) {
-	}
+			Assert.notNull(number, "Number must not be null!");
+			return project("substract", number);
+		}
 
-	private void safePop() {
+		/**
+		 * Adds a generic projection for the current field.
+		 * 
+		 * @param operation the operation key, e.g. {@code $add}.
+		 * @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));
+		}
 
-		if (!reference.empty()) {
+		/**
-			projection.put(reference.pop(), rightHandSide(1));
+		 * A {@link Projection} to pull in the result of the previous operation.
+		 * 
+		 * @author Oliver Gierke
+		 */
+		static class PreviousOperationProjection extends Projection {
+
+			private final String name;
+
+			/**
+			 * Creates a new {@link PreviousOperationProjection} for the field with the given name.
+			 * 
+			 * @param name must not be {@literal null} or empty.
+			 */
+			public PreviousOperationProjection(String name) {
+				super(Fields.field(name));
+				this.name = name;
+			}
+
+			/* 
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+			 */
+			@Override
+			public DBObject toDBObject(AggregationOperationContext context) {
+				return new BasicDBObject(name, Fields.UNDERSCORE_ID_REF);
+			}
 		}
-	}
 
-	private Object rightHandSide(Object defaultValue) {
+		/**
-		Object value = rightHandExpression != null ? rightHandExpression : defaultValue;
+		 * A {@link FieldProjection} to map a result of a previous {@link AggregationOperation} to a new field.
-		rightHandExpression = null;
+		 * 
-		return value;
+		 * @author Oliver Gierke
-	}
+		 */
+		static class FieldProjection extends Projection {
+
+			private final Field field;
+			private final Object value;
+
+			/**
+			 * Creates a new {@link FieldProjection} for the field of the given name, assigning the given value.
+			 * 
+			 * @param name must not be {@literal null} or empty.
+			 * @param value
+			 */
+			public FieldProjection(String name, Object value) {
+				this(Fields.field(name), value);
+			}
 
-	/**
+			private FieldProjection(Field field, Object value) {
-	 * @param string
+
-	 * @param projection
+				super(field);
-	 * @return
-	 */
-	public ProjectionOperation addField(String key, Object value) {
 
-		Assert.notNull(key, "Missing Key");
+				this.field = field;
-		Assert.notNull(value);
+				this.value = value;
+			}
 
-		getOutputAggregateOperationContext().registerAvailableField(key);
+			/**
-		registerAvailableFieldsRecursive(key, value);
+			 * Factory method to easily create {@link FieldProjection}s for the given {@link Fields}.
-		this.projection.put(key, value);
+			 * 
+			 * @param fields the {@link Fields} to in- or exclude, must not be {@literal null}.
+			 * @param include whether to include or exclude the fields.
+			 * @return
+			 */
+			public static List<FieldProjection> from(Fields fields, boolean include) {
 
-		return this;
+				Assert.notNull(fields, "Fields must not be null!");
-	}
+				List<FieldProjection> projections = new ArrayList<FieldProjection>();
+
+				for (Field field : fields) {
+					projections.add(new FieldProjection(field, include ? null : 0));
+				}
+
+				return projections;
+			}
 
-	private void registerAvailableFieldsRecursive(String outerKey, Object value) {
+			/* 
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+			 */
+			@Override
+			public DBObject toDBObject(AggregationOperationContext context) {
 
-		if (value instanceof Fields) {
+				if (value != null) {
-			Map<String, Object> values = ((Fields) value).getValues();
+					return new BasicDBObject(field.getName(), value);
-			for (String key : values.keySet()) {
+				}
-				String innerKey = outerKey + "." + key;
+
-				getOutputAggregateOperationContext().registerAvailableField(innerKey);
+				FieldReference reference = context.getReference(field.getTarget());
-				registerAvailableFieldsRecursive(innerKey, values.get(key));
+				return new BasicDBObject(field.getName(), reference.toString());
 			}
 		}
-	}
 
-	/**
+		static class OperationProjection extends Projection {
-	 * @param name
-	 * @param value
-	 * @return
-	 */
-	public ProjectionOperation field(String name, Object value) {
-		addField(name, value);
-		return this;
-	}
 
-	/* (non-Javadoc)
+			private final String name;
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#getOperationArgument()
+			private final String operation;
-	 */
+			private final List<Object> values;
-	@Override
-	public Object getOperationArgument(AggregateOperationContext inputAggregateOperationContext) {
 
-		Assert.notNull(inputAggregateOperationContext, "inputAggregateOperationContext must not be null");
+			/**
-		safePop();
+			 * 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 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) {
 
-		DBObject projectionObject = new BasicDBObject();
+				super(Fields.field(name));
-		for (Map.Entry<String, Object> entry : projection.entrySet()) {
-			Object fieldNameOrValueToUse = entry.getValue();
 
-			DBObject fieldsObject = returnIfValueIsIdFields(inputAggregateOperationContext, fieldNameOrValueToUse);
+				Assert.hasText(operation, "Operation must not be null or empty!");
-			if (fieldsObject != null) {
+				Assert.notNull(values, "Values must not be null!");
-				projectionObject.put(entry.getKey(), fieldsObject != null ? fieldsObject : fieldNameOrValueToUse);
+
-				continue;
+				this.name = name;
+				this.operation = operation;
+				this.values = Arrays.asList(values);
 			}
 
-			if (fieldNameOrValueToUse instanceof String) {
+			/* 
-				String fieldName = inputAggregateOperationContext
+			 * (non-Javadoc)
-						.returnFieldNameAliasIfAvailableOr((String) fieldNameOrValueToUse);
+			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
-				fieldNameOrValueToUse = ReferenceUtil.safeReference(fieldName);
+			 */
+			@Override
+			public DBObject toDBObject(AggregationOperationContext context) {
+
+				List<Object> values = buildReferences(context);
+				DBObject inner = new BasicDBObject(operation, values.size() == 1 ? values.get(0) : values.toArray());
+
+				return new BasicDBObject(name, inner);
 			}
 
-			projectionObject.put(entry.getKey(), fieldNameOrValueToUse);
+			private List<Object> buildReferences(AggregationOperationContext context) {
+
+				List<Object> result = new ArrayList<Object>(values.size());
+
+				for (Object element : values) {
+					result.add(element instanceof Field ? context.getReference((Field) element).toString() : element);
+				}
+
+				return result;
+			}
 		}
 
-		return projectionObject;
+		static class NestedFieldProjection extends Projection {
-	}
 
-	private DBObject returnIfValueIsIdFields(AggregateOperationContext inputAggregateOperationContext,
+			private final String name;
-			Object fieldNameOrValueToUse) {
+			private final Fields fields;
 
-		Assert.notNull(inputAggregateOperationContext, "inputAggregateOperationContext must not be null");
+			public NestedFieldProjection(String name, Fields fields) {
 
-		if (!(fieldNameOrValueToUse instanceof Fields)) {
+				super(Fields.field(name));
-			return null;
+				this.name = name;
-		}
+				this.fields = fields;
+			}
+
+			/* 
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+			 */
+			@Override
+			public DBObject toDBObject(AggregationOperationContext context) {
+
+				DBObject nestedObject = new BasicDBObject();
 
-		DBObject fieldsObject = new BasicDBObject();
+				for (Field field : fields) {
-		for (Map.Entry<String, Object> fieldsEntry : ((Fields) fieldNameOrValueToUse).getValues().entrySet()) {
+					nestedObject.put(field.getName(), context.getReference(field.getTarget()).toString());
+				}
 
-			Object fieldsEntryFieldNameOrValueToUse = fieldsEntry.getValue();
+				return new BasicDBObject(name, nestedObject);
-			if (fieldsEntryFieldNameOrValueToUse instanceof String && inputAggregateOperationContext != null) {
-				String fieldName = inputAggregateOperationContext
-						.returnFieldNameAliasIfAvailableOr((String) fieldsEntryFieldNameOrValueToUse);
-				fieldsEntryFieldNameOrValueToUse = ReferenceUtil.safeReference(fieldName);
 			}
-			fieldsObject.put(fieldsEntry.getKey(), fieldsEntryFieldNameOrValueToUse);
 		}
-		return fieldsObject;
+	}
+
+	private static abstract class Projection {
+
+		private final ExposedField field;
+
+		public Projection(Field name) {
+
+			Assert.notNull(name, "Field must not be null!");
+			this.field = new ExposedField(name, true);
+		}
+
+		public ExposedField getField() {
+			return field;
+		}
+
+		public abstract DBObject toDBObject(AggregationOperationContext context);
 	}
 }

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

@@ -1,121 +0,0 @@
-/*
- * 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;
-
-import org.springframework.util.Assert;
-
-/**
- * Utility class for mongo db reference operator <code>$</code>
- * 
- * @author Sebastian Herold
- * @author Thomas Darimont
- * @since 1.3
- */
-class ReferenceUtil {
-
-	public static final String ID_KEY = "_id";
-
-	private static final String REFERENCE_PREFIX = "$";
-
-	/**
-	 * Ensures that the returned string begins with {@link #REFERENCE_PREFIX}.
-	 * 
-	 * @param key reference key with or without {@link #REFERENCE_PREFIX} at the beginning.
-	 * @return key that definitely begins with {@link #REFERENCE_PREFIX}.
-	 */
-	public static String safeReference(String key) {
-
-		Assert.hasText(key);
-
-		if (!key.startsWith(REFERENCE_PREFIX)) {
-			return REFERENCE_PREFIX + key;
-		} else {
-			return key;
-		}
-	}
-
-	/**
-	 * Ensures that the returned string does not start with {@link #REFERENCE_PREFIX}.
-	 * 
-	 * @param field reference key with or without {@link #REFERENCE_PREFIX} at the beginning.
-	 * @return key that definitely does not begin with {@link #REFERENCE_PREFIX}.
-	 */
-	public static String safeNonReference(String field) {
-
-		Assert.hasText(field);
-
-		if (field.startsWith(REFERENCE_PREFIX)) {
-			return field.substring(REFERENCE_PREFIX.length());
-		}
-
-		return field;
-	}
-
-	/**
-	 * @return $_id
-	 */
-	public static String $id() {
-		return $(ID_KEY);
-	}
-
-	/**
-	 * <pre>
-	 *  $("a") -> $a
-	 * </pre>
-	 * 
-	 * @param fieldName
-	 * @return the field name prefixed with {@literal $}
-	 * @see #safeReference(String)
-	 */
-	public static String $(String fieldName) {
-		return safeReference(fieldName);
-	}
-
-	/**
-	 * <pre>
-	 * 	$id("a") -> $_id.a
-	 * </pre>
-	 * 
-	 * @param fieldName
-	 * @return
-	 * @see #safeNonReference(String)
-	 */
-	public static String $id(String fieldName) {
-		return $id() + "." + safeNonReference(fieldName);
-	}
-
-	/**
-	 * @param fieldName
-	 * @return
-	 */
-	public static String id(String fieldName) {
-		return ID_KEY + "." + fieldName;
-	}
-
-	/**
-	 * <pre>
-	 * a: $a -> true
-	 * </pre>
-	 * 
-	 * @param idFieldName
-	 * @param idFieldValue
-	 * @return true if {@code idFieldValue} corresponds to the given {@code idFieldName} e.g.
-	 */
-	public static boolean isValueFieldReference(String idFieldName, Object idFieldValue) {
-		return idFieldValue instanceof String && idFieldName.equals(safeNonReference((String) idFieldValue));
-	}
-
-}

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

@@ -15,26 +15,40 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import org.springframework.util.Assert;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
 /**
  * Encapsulates the aggregation framework {@code $skip}-operation.
  * 
  * @see http://docs.mongodb.org/manual/reference/aggregation/skip/
  * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public class SkipOperation extends AbstractAggregateOperation {
+public class SkipOperation implements AggregationOperation {
 
 	private final long skipCount;
 
 	/**
+	 * Creates a new {@link SkipOperation} skipping the given number of elements.
+	 * 
 	 * @param skipCount number of documents to skip.
 	 */
 	public SkipOperation(long skipCount) {
-		super("skip");
+
+		Assert.isTrue(skipCount >= 0, "Skip count must not be negative!");
 		this.skipCount = skipCount;
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
 	@Override
-	public Object getOperationArgument() {
+	public DBObject toDBObject(AggregationOperationContext context) {
-		return skipCount;
+		return new BasicDBObject("$skip", skipCount);
 	}
 }

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

@@ -16,6 +16,9 @@
 package org.springframework.data.mongodb.core.aggregation;
 
 import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Direction;
+import org.springframework.data.domain.Sort.Order;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
 import org.springframework.util.Assert;
 
 import com.mongodb.BasicDBObject;
@@ -26,42 +29,48 @@ import com.mongodb.DBObject;
  * 
  * @see http://docs.mongodb.org/manual/reference/aggregation/sort/#pipe._S_sort
  * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public class SortOperation extends AbstractContextAwareAggregateOperation implements ContextConsumingAggregateOperation {
+public class SortOperation implements AggregationOperation {
 
-	private Sort sort;
+	private final Sort sort;
 
 	/**
-	 * @param sort
+	 * Creates a new {@link SortOperation} for the given {@link Sort} instance.
+	 * 
+	 * @param sort must not be {@literal null}.
 	 */
 	public SortOperation(Sort sort) {
-		super("sort");
 
-		Assert.notNull(sort);
+		Assert.notNull(sort, "Sort must not be null!");
 		this.sort = sort;
 	}
 
-	public SortOperation and(Sort sort) {
+	public SortOperation and(Direction direction, String... fields) {
-		return new SortOperation(this.sort.and(sort));
+		return and(new Sort(direction, fields));
 	}
 
-	public SortOperation and(Sort.Direction direction, String... fields) {
+	public SortOperation and(Sort sort) {
-		return and(new Sort(direction, fields));
+		return new SortOperation(this.sort.and(sort));
 	}
 
-	/* (non-Javadoc)
+	/* 
-	 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregateOperation#getOperationArgument()
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
 	 */
 	@Override
-	public Object getOperationArgument(AggregateOperationContext inputAggregateOperationContext) {
+	public DBObject toDBObject(AggregationOperationContext context) {
 
-		Assert.notNull(inputAggregateOperationContext, "inputAggregateOperationContext must not be null!");
+		BasicDBObject object = new BasicDBObject();
 
-		DBObject sortProperties = new BasicDBObject();
+		for (Order order : sort) {
-		for (org.springframework.data.domain.Sort.Order order : sort) {
+
-			String fieldName = inputAggregateOperationContext.returnFieldNameAliasIfAvailableOr(order.getProperty());
+			// Check reference
-			sortProperties.put(fieldName, order.isAscending() ? 1 : -1);
+			FieldReference reference = context.getReference(order.getProperty());
+			object.put(reference.getRaw(), order.isAscending() ? 1 : -1);
 		}
-		return sortProperties;
+
+		return new BasicDBObject("$sort", object);
 	}
 }

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

@@ -0,0 +1,102 @@
+/*
+ * 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;
+
+import static org.springframework.data.mongodb.core.aggregation.Fields.*;
+
+import org.springframework.data.mapping.PropertyPath;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.context.PersistentPropertyPath;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.util.Assert;
+
+import com.mongodb.DBObject;
+
+/**
+ * {@link AggregationOperationContext} aware of a particular type and a {@link MappingContext} to potentially translate
+ * property references into document field names.
+ * 
+ * @author Oliver Gierke
+ * @since 1.3
+ */
+public class TypeBasedAggregationOperationContext implements AggregationOperationContext {
+
+	private final Class<?> type;
+	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+	private final QueryMapper mapper;
+
+	/**
+	 * Creates a new {@link TypeBasedAggregationOperationContext} for the given type, {@link MappingContext} and
+	 * {@link QueryMapper}.
+	 * 
+	 * @param type must not be {@literal null}.
+	 * @param mappingContext must not be {@literal null}.
+	 * @param mapper must not be {@literal null}.
+	 */
+	public TypeBasedAggregationOperationContext(Class<?> type,
+			MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext, QueryMapper mapper) {
+
+		Assert.notNull(type, "Type must not be null!");
+		Assert.notNull(mappingContext, "MappingContext must not be null!");
+		Assert.notNull(mapper, "QueryMapper must not be null!");
+
+		this.type = type;
+		this.mappingContext = mappingContext;
+		this.mapper = mapper;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getMappedObject(com.mongodb.DBObject)
+	 */
+	@Override
+	public DBObject getMappedObject(DBObject dbObject) {
+		return mapper.getMappedObject(dbObject, mappingContext.getPersistentEntity(type));
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(org.springframework.data.mongodb.core.aggregation.ExposedFields.AvailableField)
+	 */
+	@Override
+	public FieldReference getReference(Field field) {
+
+		PropertyPath.from(field.getName(), type);
+		return getReferenceFor(field);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
+	 */
+	@Override
+	public FieldReference getReference(String name) {
+		PropertyPath path = PropertyPath.from(name, type);
+
+		PersistentPropertyPath<MongoPersistentProperty> propertyPath = mappingContext.getPersistentPropertyPath(path);
+
+		return getReferenceFor(field(path.getLeafProperty().getSegment(),
+				propertyPath.toDotPath(MongoPersistentProperty.PropertyToFieldNameConverter.INSTANCE)));
+	}
+
+	private FieldReference getReferenceFor(Field field) {
+		return new FieldReference(new ExposedField(field, true));
+	}
+}

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

@@ -15,14 +15,17 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import org.springframework.util.Assert;
+
 /**
  * A {@code TypedAggregation} is a special {@link Aggregation} that holds information of the input aggregation type.
  * 
  * @author Thomas Darimont
+ * @author Oliver Gierke
  */
-public class TypedAggregation<I, O> extends Aggregation<I, O> {
+public class TypedAggregation<I> extends Aggregation {
 
-	private Class<I> inputType;
+	private final Class<I> inputType;
 
 	/**
 	 * Creates a new {@link TypedAggregation} from the given {@link AggregationOperation}s.
@@ -30,20 +33,19 @@ public class TypedAggregation<I, O> extends Aggregation<I, O> {
 	 * @param operations must not be {@literal null} or empty.
 	 */
 	public TypedAggregation(Class<I> inputType, AggregationOperation... operations) {
+
 		super(operations);
+
+		Assert.notNull(inputType, "Input type must not be null!");
 		this.inputType = inputType;
 	}
 
 	/**
-	 * @return the inputType
+	 * Returns the input type for the {@link Aggregation}.
+	 * 
+	 * @return the inputType will never be {@literal null}.
 	 */
-	public Class<?> getInputType() {
+	public Class<I> getInputType() {
 		return inputType;
 	}
-
-	protected AggregateOperationContext createInitialAggregateOperationContext() {
-
-		// TODO construct initial aggregate operation context from input type.
-		return super.createInitialAggregateOperationContext();
-	}
 }

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

@@ -15,30 +15,50 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
 import org.springframework.util.Assert;
 
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
 /**
  * Encapsulates the aggregation framework {@code $unwind}-operation.
  * 
  * @see http://docs.mongodb.org/manual/reference/aggregation/unwind/#pipe._S_unwind
  * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.3
  */
-public class UnwindOperation extends AbstractContextProducingAggregateOperation implements
+public class UnwindOperation extends ExposedFieldsAggregationOperationContext implements AggregationOperation {
-		ContextConsumingAggregateOperation {
 
-	private final String fieldName;
+	private final ExposedField field;
 
-	public UnwindOperation(String fieldName) {
+	/**
+	 * Creates a new {@link UnwindOperation} for the given {@link Field}.
+	 * 
+	 * @param field must not be {@literal null}.
+	 */
+	public UnwindOperation(Field field) {
 
-		super("unwind");
+		Assert.notNull(field);
-		Assert.notNull(fieldName);
+		this.field = new ExposedField(field, true);
-		this.fieldName = fieldName;
+	}
 
-		getOutputAggregateOperationContext().registerAvailableField(fieldName, fieldName);
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.ExposedFieldsAggregationOperationContext#getFields()
+	 */
+	@Override
+	protected ExposedFields getFields() {
+		return ExposedFields.from(field);
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDBObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
 	@Override
-	public Object getOperationArgument(AggregateOperationContext inputAggregateOperationContext) {
+	public DBObject toDBObject(AggregationOperationContext context) {
-		return ReferenceUtil.safeReference(fieldName);
+		return new BasicDBObject("$unwind", context.getReference(field).toString());
 	}
 }

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

@@ -1,19 +1,5 @@
-/*
- * 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.
- */
 /**
- * @author Thomas Darimont
+ * Support for the MongoDB aggregation framework.
+ * @since 1.3
  */
 package org.springframework.data.mongodb.core.aggregation;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java

@@ -356,7 +356,7 @@ public class QueryMapper {
 		protected final String name;
 
 		/**
-		 * Creates a new {@link Field} without meta-information but the given name.
+		 * Creates a new {@link DocumentField} without meta-information but the given name.
 		 * 
 		 * @param name must not be {@literal null} or empty.
 		 */
@@ -367,7 +367,7 @@ public class QueryMapper {
 		}
 
 		/**
-		 * Returns a new {@link Field} with the given name.
+		 * Returns a new {@link DocumentField} with the given name.
 		 * 
 		 * @param name must not be {@literal null} or empty.
 		 * @return
@@ -423,7 +423,7 @@ public class QueryMapper {
 	}
 
 	/**
-	 * Extension of {@link Field} to be backed with mapping metadata.
+	 * Extension of {@link DocumentField} to be backed with mapping metadata.
 	 * 
 	 * @author Oliver Gierke
 	 */

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentEntity.java

@@ -51,7 +51,7 @@ import org.springframework.util.StringUtils;
 public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, MongoPersistentProperty> implements
 		MongoPersistentEntity<T>, ApplicationContextAware {
 
-	private static final String AMBIGUOUS_FIELD_MAPPING = "Ambiguous field mapping detected! Both %s and %s map to the same field name %s! Disambiguate using @Field annotation!";
+	private static final String AMBIGUOUS_FIELD_MAPPING = "Ambiguous field mapping detected! Both %s and %s map to the same field name %s! Disambiguate using @DocumentField annotation!";
 	private final String collection;
 	private final SpelExpressionParser parser;
 	private final StandardEvaluationContext context;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/FieldNamingStrategy.java

@@ -18,7 +18,7 @@ package org.springframework.data.mongodb.core.mapping;
 /**
  * SPI interface to determine how to name document fields in cases the field name is not manually defined.
  * 
- * @see Field
+ * @see DocumentField
  * @see PropertyNameFieldNamingStrategy
  * @see CamelCaseAbbreviatingFieldNamingStrategy
  * @since 1.3

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java

@@ -73,7 +73,7 @@ public class Field {
 	 */
 	public Field position(String field, int value) {
 
-		Assert.hasText(field, "Field must not be null or empty!");
+		Assert.hasText(field, "DocumentField must not be null or empty!");
 
 		postionKey = field;
 		positionValue = value;

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

@@ -0,0 +1,95 @@
+/*
+ * 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;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.MongoTemplate.UnwrapAndReadDbObjectCallback;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+
+import com.mongodb.BasicDBObject;
+
+/**
+ * Unit tests for {@link UnwrapAndReadDbObjectCallback}.
+ * 
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class UnwrapAndReadDbObjectCallbackUnitTests {
+
+	@Mock MongoDbFactory factory;
+
+	UnwrapAndReadDbObjectCallback<Target> callback;
+
+	@Before
+	public void setUp() {
+
+		MongoTemplate template = new MongoTemplate(factory);
+		MappingMongoConverter converter = new MappingMongoConverter(factory, new MongoMappingContext());
+
+		this.callback = template.new UnwrapAndReadDbObjectCallback<Target>(converter, Target.class);
+	}
+
+	@Test
+	public void usesFirstLevelValues() {
+
+		Target target = callback.doWith(new BasicDBObject("foo", "bar"));
+
+		assertThat(target.id, is(nullValue()));
+		assertThat(target.foo, is("bar"));
+	}
+
+	@Test
+	public void unwrapsUnderscoreIdIfBasicDBObject() {
+
+		Target target = callback.doWith(new BasicDBObject("_id", new BasicDBObject("foo", "bar")));
+
+		assertThat(target.id, is(nullValue()));
+		assertThat(target.foo, is("bar"));
+	}
+
+	@Test
+	public void firstLevelPropertiesTrumpNestedOnes() {
+
+		Target target = callback.doWith(new BasicDBObject("_id", new BasicDBObject("foo", "bar")).append("foo", "foobar"));
+
+		assertThat(target.id, is(nullValue()));
+		assertThat(target.foo, is("foobar"));
+	}
+
+	@Test
+	public void keepsUnderscoreIdIfScalarValue() {
+
+		Target target = callback.doWith(new BasicDBObject("_id", "bar").append("foo", "foo"));
+
+		assertThat(target.id, is("bar"));
+		assertThat(target.foo, is("foo"));
+	}
+
+	static class Target {
+
+		String id;
+		String foo;
+	}
+}

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

@@ -1,92 +0,0 @@
-/*
- * 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;
-
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
-import static org.springframework.data.domain.Sort.Direction.*;
-import static org.springframework.data.mongodb.core.DBObjectUtils.*;
-import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
-
-import org.junit.Test;
-import org.springframework.data.mongodb.core.query.Criteria;
-
-import com.mongodb.DBObject;
-
-/**
- * Tests of the {@link AggregationPipeline}.
- * 
- * @see DATAMONGO-586
- * @author Tobias Trelle
- * @author Thomas Darimont
- */
-public class AggregationPipelineTests {
-
-	@Test
-	public void limitOperation() {
-
-		assertSingleDBObject("$limit", 42L, limit(42).toDbObject());
-	}
-
-	@Test
-	public void skipOperation() {
-
-		assertSingleDBObject("$skip", 5L, skip(5).toDbObject());
-	}
-
-	@Test
-	public void unwindOperation() {
-
-		assertSingleDBObject("$unwind", "$field", unwind("$field").toDbObject(new BasicAggregateOperationContext()));
-	}
-
-	@Test
-	public void unwindOperationWithAddedPrefix() {
-
-		assertSingleDBObject("$unwind", "$field", unwind("field").toDbObject(new BasicAggregateOperationContext()));
-	}
-
-	@Test
-	public void matchOperation() {
-
-		DBObject match = match(new Criteria("title").is("Doc 1")).toDbObject();
-		DBObject criteriaDoc = getAsDBObject(match, "$match");
-		assertThat(criteriaDoc, is(notNullValue()));
-		assertSingleDBObject("title", "Doc 1", criteriaDoc);
-	}
-
-	@Test
-	public void sortOperation() {
-
-		DBObject sortDoc = sort(ASC, "n").toDbObject(new BasicAggregateOperationContext());
-		DBObject orderDoc = getAsDBObject(sortDoc, "$sort");
-		assertThat(orderDoc, is(notNullValue()));
-		assertSingleDBObject("n", 1, orderDoc);
-	}
-
-	@Test
-	public void projectOperation() {
-
-		DBObject projectionDoc = project("a").toDbObject(new BasicAggregateOperationContext());
-		DBObject fields = getAsDBObject(projectionDoc, "$project");
-		assertThat(fields, is(notNullValue()));
-		assertSingleDBObject("a", 1, fields);
-	}
-
-	private static void assertSingleDBObject(String key, Object value, DBObject doc) {
-		assertThat(doc.get(key), is(value));
-	}
-}

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

@@ -55,26 +55,24 @@ import com.mongodb.util.JSON;
  * @see DATAMONGO-586
  * @author Tobias Trelle
  * @author Thomas Darimont
+ * @author Oliver Gierke
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration("classpath:infrastructure.xml")
 public class AggregationTests {
 
 	private static final String INPUT_COLLECTION = "aggregation_test_collection";
-	private static boolean initialized = false;
 	private static final Logger LOGGER = LoggerFactory.getLogger(AggregationTests.class);
 
+	private static boolean initialized = false;
+
 	@Autowired MongoTemplate mongoTemplate;
 
 	@Before
 	public void setUp() {
+
 		cleanDb();
 		initSampleDataIfNecessary();
-
-		CommandResult result = mongoTemplate.executeCommand("{ buildInfo: 1 }");
-		Object version = result.get("version");
-
-		LOGGER.debug("Server uses MongoDB Version: {}", version);
 	}
 
 	@After
@@ -97,8 +95,9 @@ public class AggregationTests {
 
 		if (!initialized) {
 
-			CommandResult result = mongoTemplate.executeCommand(new BasicDBObject("buildInfo", 1));
+			CommandResult result = mongoTemplate.executeCommand("{ buildInfo: 1 }");
-			LOGGER.error(result.toString());
+			Object version = result.get("version");
+			LOGGER.debug("Server uses MongoDB Version: {}", version);
 
 			mongoTemplate.dropCollection(ZipInfo.class);
 			mongoTemplate.execute(ZipInfo.class, new CollectionCallback<Void>() {
@@ -133,17 +132,17 @@ public class AggregationTests {
 
 	@Test(expected = IllegalArgumentException.class)
 	public void shouldHandleMissingInputCollection() {
-		mongoTemplate.aggregate((String) null, new Aggregation<Object, TagCount>(), TagCount.class);
+		mongoTemplate.aggregate(newAggregation(), (String) null, TagCount.class);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void shouldHandleMissingAggregationPipeline() {
-		mongoTemplate.aggregate(INPUT_COLLECTION, null, TagCount.class);
+		mongoTemplate.aggregate(null, INPUT_COLLECTION, TagCount.class);
 	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void shouldHandleMissingEntityClass() {
-		mongoTemplate.aggregate(INPUT_COLLECTION, new Aggregation<Object, TagCount>(), null);
+		mongoTemplate.aggregate(newAggregation(), INPUT_COLLECTION, null);
 	}
 
 	@Test
@@ -151,20 +150,22 @@ public class AggregationTests {
 
 		createTagDocuments();
 
-		Aggregation<Object, TagCount> agg = newAggregation( //
+		Aggregation agg = newAggregation( //
 				project("tags"), //
 				unwind("tags"), //
-				group("tags").count("n"), //
+				group("tags") //
-				project().field("tag", $id()).field("n", 1), //
+						.and("n").count(), //
+				project("n") //
+						.and("tag").previousOperation(), //
 				sort(DESC, "n") //
 		);
 
-		AggregationResults<TagCount> results = mongoTemplate.aggregate(INPUT_COLLECTION, agg, TagCount.class);
+		AggregationResults<TagCount> results = mongoTemplate.aggregate(agg, INPUT_COLLECTION, TagCount.class);
 
 		assertThat(results, is(notNullValue()));
 		assertThat(results.getServerUsed(), is("/127.0.0.1:27017"));
 
-		List<TagCount> tagCount = results.getAggregationResult();
+		List<TagCount> tagCount = results.getMappedResults();
 
 		assertThat(tagCount, is(notNullValue()));
 		assertThat(tagCount.size(), is(3));
@@ -177,20 +178,22 @@ public class AggregationTests {
 	@Test
 	public void shouldAggregateEmptyCollection() {
 
-		Aggregation<Object, TagCount> agg = newAggregation(//
+		Aggregation aggregation = newAggregation(//
 				project("tags"), //
 				unwind("tags"), //
-				group("tags").count("n"), //
+				group("tags") //
-				project().field("tag", $id()).field("n", 1), //
+						.and("n").count(), //
+				project("n") //
+						.and("tag").previousOperation(), //
 				sort(DESC, "n") //
 		);
 
-		AggregationResults<TagCount> results = mongoTemplate.aggregate(INPUT_COLLECTION, agg, TagCount.class);
+		AggregationResults<TagCount> results = mongoTemplate.aggregate(aggregation, INPUT_COLLECTION, TagCount.class);
 
 		assertThat(results, is(notNullValue()));
 		assertThat(results.getServerUsed(), is("/127.0.0.1:27017"));
 
-		List<TagCount> tagCount = results.getAggregationResult();
+		List<TagCount> tagCount = results.getMappedResults();
 
 		assertThat(tagCount, is(notNullValue()));
 		assertThat(tagCount.size(), is(0));
@@ -200,19 +203,21 @@ public class AggregationTests {
 	public void shouldDetectResultMismatch() {
 
 		createTagDocuments();
-		Aggregation<Object, TagCount> agg = newAggregation( //
+
+		Aggregation aggregation = newAggregation( //
 				project("tags"), //
 				unwind("tags"), //
-				group("tags").count("count"), //
+				group("tags") //
+						.and("count").count(), //
 				limit(2) //
 		);
 
-		AggregationResults<TagCount> results = mongoTemplate.aggregate(INPUT_COLLECTION, agg, TagCount.class);
+		AggregationResults<TagCount> results = mongoTemplate.aggregate(aggregation, INPUT_COLLECTION, TagCount.class);
 
 		assertThat(results, is(notNullValue()));
 		assertThat(results.getServerUsed(), is("/127.0.0.1:27017"));
 
-		List<TagCount> tagCount = results.getAggregationResult();
+		List<TagCount> tagCount = results.getMappedResults();
 
 		assertThat(tagCount, is(notNullValue()));
 		assertThat(tagCount.size(), is(2));
@@ -220,61 +225,6 @@ public class AggregationTests {
 		assertTagCount(null, 0, tagCount.get(1));
 	}
 
-	@Test
-	public void fieldsFactoryMethod() {
-
-		Fields fields = fields("a", "b").and("c").and("d", 42);
-		assertThat(fields, is(notNullValue()));
-		assertThat(fields.getValues(), is(notNullValue()));
-		assertThat(fields.getValues().size(), is(4));
-		assertThat(fields.getValues().get("a"), is((Object) "a"));
-		assertThat(fields.getValues().get("b"), is((Object) "b"));
-		assertThat(fields.getValues().get("c"), is((Object) "c"));
-		assertThat(fields.getValues().get("d"), is((Object) 42));
-	}
-
-	@Test
-	public void shouldCreateSimpleIdForGroupOperationWithSingleSimpleIdField() {
-
-		Fields fields = fields("a");
-		GroupOperation groupOperation = new GroupOperation(fields);
-
-		DBObject dbObject = groupOperation.toDbObject(new BasicAggregateOperationContext());
-		assertThat(dbObject, is(notNullValue()));
-		assertThat(dbObject.get("$group"), is(notNullValue()));
-		assertThat(((DBObject) dbObject.get("$group")).get(id()), is(notNullValue()));
-		assertThat(((DBObject) dbObject.get("$group")).get(id()), is((Object) "$a"));
-	}
-
-	@Test
-	public void shouldCreateComplexIdForGroupOperationWithSingleComplexIdField() {
-
-		Fields fields = fields().and("a", 42);
-		GroupOperation groupOperation = new GroupOperation(fields);
-
-		assertThat(groupOperation.toDbObject(new BasicAggregateOperationContext()), is(notNullValue()));
-		assertThat(groupOperation.id, is(notNullValue()));
-		assertThat(groupOperation.id, is((Object) new BasicDBObject("a", 42)));
-	}
-
-	// @Test
-	// public void groupFactoryMethodWithMultipleFieldsAndSumOperation() {
-	//
-	// Fields fields = fields("a", "b").pick("c").pick("d", 42);
-	// GroupOperation groupOperation = group(fields).sum("e");
-	//
-	// assertThat(groupOperation, is(notNullValue()));
-	// assertThat(groupOperation.toDbObject(null), is(notNullValue()));
-	// assertThat(groupOperation.id, is(notNullValue()));
-	// assertThat(groupOperation.id, is((Object) new BasicDBObject(fields.getValues())));
-	// assertThat(groupOperation.fields, is(notNullValue()));
-	// assertThat(groupOperation.fields.size(), is(1));
-	// assertThat(groupOperation.fields.containsKey("e"), is(true));
-	// assertThat(groupOperation.fields.get("e"), is(notNullValue()));
-	// assertThat(groupOperation.fields.get("e").get("$sum"), is(notNullValue()));
-	// assertThat(groupOperation.fields.get("e").get("$sum"), is((Object) "$e"));
-	// }
-
 	@Test
 	public void complexAggregationFrameworkUsageLargestAndSmallestCitiesByState() {
 		/*
@@ -337,31 +287,31 @@ public class AggregationTests {
 		)
 		*/
 
-		TypedAggregation<ZipInfo, ZipInfoStats> agg = newAggregation(ZipInfo.class, //
+		TypedAggregation<ZipInfo> aggregation = newAggregation(ZipInfo.class, //
-				group("state", "city").sum("pop"), //
+				group("state", "city").and("pop").sum("population"), //
 				sort(ASC, "pop", "state", "city"), //
 				group("state") //
-						.last("biggestCity", "city") //
+						.and("biggestCity").last("city") //
-						.last("biggestPop", "pop") //
+						.and("biggestPop").last("pop") //
-						.first("smallestCity", "city") //
+						.and("smallestCity").first("city") //
-						.first("smallestPop", "pop"), //
+						.and("smallestPop").first("pop"), //
-				project(ZipInfoStats.class) //
+				project() //
-						.field("_id", 0) //
+						// .and(previousOperation()).exclude() //
-						.field("state", id()) //
+						.and("state").previousOperation() //
-						.field("biggestCity", pick("name", "biggestCity").and("population", "biggestPop")) //
+						.and("biggestCity").nested(bind("name", "biggestCity").and("population", "biggestPop")) //
-						.field("smallestCity", pick("name", "smallestCity").and("population", "smallestPop")), //
+						.and("smallestCity").nested(bind("name", "smallestCity").and("population", "smallestPop")), //
 				sort(ASC, "state") //
 		);
 
-		assertThat(agg, is(notNullValue()));
+		assertThat(aggregation, is(notNullValue()));
-		assertThat(agg.toString(), is(notNullValue()));
+		assertThat(aggregation.toString(), is(notNullValue()));
 
-		AggregationResults<ZipInfoStats> result = mongoTemplate.aggregate(agg, ZipInfoStats.class);
+		AggregationResults<ZipInfoStats> result = mongoTemplate.aggregate(aggregation, ZipInfoStats.class);
 		assertThat(result, is(notNullValue()));
-		assertThat(result.getAggregationResult(), is(notNullValue()));
+		assertThat(result.getMappedResults(), is(notNullValue()));
-		assertThat(result.getAggregationResult().size(), is(51));
+		assertThat(result.getMappedResults().size(), is(51));
 
-		ZipInfoStats firstZipInfoStats = result.getAggregationResult().get(0);
+		ZipInfoStats firstZipInfoStats = result.getMappedResults().get(0);
 		assertThat(firstZipInfoStats, is(notNullValue()));
 		assertThat(firstZipInfoStats.id, is(nullValue()));
 		assertThat(firstZipInfoStats.state, is("AK"));
@@ -372,7 +322,7 @@ public class AggregationTests {
 		assertThat(firstZipInfoStats.biggestCity.name, is("ANCHORAGE"));
 		assertThat(firstZipInfoStats.biggestCity.population, is(183987));
 
-		ZipInfoStats lastZipInfoStats = result.getAggregationResult().get(50);
+		ZipInfoStats lastZipInfoStats = result.getMappedResults().get(50);
 		assertThat(lastZipInfoStats, is(notNullValue()));
 		assertThat(lastZipInfoStats.id, is(nullValue()));
 		assertThat(lastZipInfoStats.state, is("WY"));
@@ -408,9 +358,10 @@ public class AggregationTests {
 		)
 		  */
 
-		TypedAggregation<ZipInfo, StateStats> agg = newAggregation(ZipInfo.class, //
+		TypedAggregation<ZipInfo> agg = newAggregation(ZipInfo.class, //
-				group("state").sum("totalPop", "pop"), //
+				group("state") //
-				sort(ASC, id(), "totalPop"), //
+						.and("totalPop").sum("population"), //
+				sort(ASC, previousOperation(), "totalPop"), //
 				match(where("totalPop").gte(10 * 1000 * 1000)) //
 		);
 
@@ -419,10 +370,10 @@ public class AggregationTests {
 
 		AggregationResults<StateStats> result = mongoTemplate.aggregate(agg, StateStats.class);
 		assertThat(result, is(notNullValue()));
-		assertThat(result.getAggregationResult(), is(notNullValue()));
+		assertThat(result.getMappedResults(), is(notNullValue()));
-		assertThat(result.getAggregationResult().size(), is(7));
+		assertThat(result.getMappedResults().size(), is(7));
 
-		StateStats stateStats = result.getAggregationResult().get(0);
+		StateStats stateStats = result.getMappedResults().get(0);
 		assertThat(stateStats, is(notNullValue()));
 		assertThat(stateStats.id, is("CA"));
 		assertThat(stateStats.state, is(nullValue()));
@@ -447,12 +398,12 @@ public class AggregationTests {
 		 
 		 */
 
-		TypedAggregation<UserWithLikes, LikeStats> agg = newAggregation(UserWithLikes.class, //
+		TypedAggregation<UserWithLikes> agg = newAggregation(UserWithLikes.class, //
 				unwind("likes"), //
-				group("likes").count("number"), //
+				group("likes").and("number").count(), //
 				sort(DESC, "number"), //
 				limit(5), //
-				sort(ASC, id()) //
+				sort(ASC, previousOperation()) //
 		);
 
 		assertThat(agg, is(notNullValue()));
@@ -460,14 +411,14 @@ public class AggregationTests {
 
 		AggregationResults<LikeStats> result = mongoTemplate.aggregate(agg, LikeStats.class);
 		assertThat(result, is(notNullValue()));
-		assertThat(result.getAggregationResult(), is(notNullValue()));
+		assertThat(result.getMappedResults(), is(notNullValue()));
-		assertThat(result.getAggregationResult().size(), is(5));
+		assertThat(result.getMappedResults().size(), is(5));
-
+
-		assertLikeStats(result.getAggregationResult().get(0), "a", 4);
+		assertLikeStats(result.getMappedResults().get(0), "a", 4);
-		assertLikeStats(result.getAggregationResult().get(1), "b", 2);
+		assertLikeStats(result.getMappedResults().get(1), "b", 2);
-		assertLikeStats(result.getAggregationResult().get(2), "c", 4);
+		assertLikeStats(result.getMappedResults().get(2), "c", 4);
-		assertLikeStats(result.getAggregationResult().get(3), "d", 2);
+		assertLikeStats(result.getMappedResults().get(3), "d", 2);
-		assertLikeStats(result.getAggregationResult().get(4), "e", 3);
+		assertLikeStats(result.getMappedResults().get(4), "e", 3);
 	}
 
 	private void assertLikeStats(LikeStats like, String id, long count) {

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

@@ -0,0 +1,46 @@
+/*
+ * 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;
+
+import org.junit.Test;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
+
+/**
+ * @author Oliver Gierke
+ */
+public class AggregationUnitTests {
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullAggregationOperation() {
+		Aggregation.newAggregation((AggregationOperation[]) null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullTypedAggregationOperation() {
+		Aggregation.newAggregation(String.class, (AggregationOperation[]) null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNoAggregationOperation() {
+		Aggregation.newAggregation(new AggregationOperation[0]);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNoTypedAggregationOperation() {
+		Aggregation.newAggregation(String.class, new AggregationOperation[0]);
+	}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+
+/**
+ * Unit tests for {@link ExposedFields}.
+ * 
+ * @author Oliver Gierke
+ */
+public class ExposedFieldsUnitTests {
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFields() {
+		ExposedFields.from((ExposedField) null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldsForSynthetics() {
+		ExposedFields.synthetic(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldsForNonSynthetics() {
+		ExposedFields.nonSynthetic(null);
+	}
+
+	@Test
+	public void exposesSingleField() {
+
+		ExposedFields fields = ExposedFields.synthetic(Fields.fields("foo"));
+		assertThat(fields.exposesSingleFieldOnly(), is(true));
+
+		fields = fields.and(new ExposedField("bar", true));
+		assertThat(fields.exposesSingleFieldOnly(), is(false));
+	}
+}

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

@@ -0,0 +1,115 @@
+/*
+ * 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;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.springframework.data.mongodb.core.aggregation.Fields.*;
+
+import org.hamcrest.Matchers;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.springframework.data.mongodb.core.aggregation.Fields.AggregationField;
+
+/**
+ * Unit tests for {@link Fields}.
+ * 
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ */
+public class FieldsUnitTests {
+
+	@Rule public ExpectedException exception = ExpectedException.none();
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldVarArgs() {
+		Fields.from((Field[]) null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldNameVarArgs() {
+		Fields.fields((String[]) null);
+	}
+
+	@Test
+	public void createsFieldFromNameOnly() {
+		verify(Fields.field("foo"), "foo", null);
+	}
+
+	@Test
+	public void createsFieldFromNameAndTarget() {
+		verify(Fields.field("foo", "bar"), "foo", "bar");
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldName() {
+		Fields.field(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFieldNameIfTargetGiven() {
+		Fields.field(null, "foo");
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsEmptyFieldName() {
+		Fields.field("");
+	}
+
+	@Test
+	public void createsFieldsFromFieldInstances() {
+
+		AggregationField reference = new AggregationField("foo");
+		Fields fields = Fields.from(reference);
+
+		assertThat(fields, is(Matchers.<Field> iterableWithSize(1)));
+		assertThat(fields, hasItem(reference));
+	}
+
+	@Test
+	public void aliasesPathExpressionsIntoLeafForImplicits() {
+		verify(Fields.field("foo.bar"), "bar", "foo.bar");
+	}
+
+	@Test
+	public void fieldsFactoryMethod() {
+
+		Fields fields = fields("a", "b").and("c").and("d", "e");
+
+		assertThat(fields, is(Matchers.<Field> iterableWithSize(4)));
+
+		verify(fields.getField("a"), "a", null);
+		verify(fields.getField("b"), "b", null);
+		verify(fields.getField("c"), "c", null);
+		verify(fields.getField("d"), "d", "e");
+	}
+
+	@Test
+	public void rejectsAmbiguousFieldNames() {
+
+		exception.expect(IllegalArgumentException.class);
+
+		fields("b", "a.b");
+	}
+
+	private static void verify(Field field, String name, String target) {
+
+		assertThat(field, is(notNullValue()));
+		assertThat(field.getName(), is(name));
+		assertThat(field.getTarget(), is(target != null ? target : name));
+	}
+}

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

@@ -15,22 +15,30 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.data.mongodb.core.DBObjectUtils;
+import org.springframework.data.mongodb.core.query.NearQuery;
+
 import com.mongodb.DBObject;
 
 /**
- * Represents one single operation in an aggregation pipeline that is aware of an {@link AggregateOperationContext}. The
+ * Unit tests for {@link GeoNearOperation}.
- * {@code AggregateOperationContext} can be used to resolve the correct field reference expression for field references.
  * 
- * @author Thomas Darimont
+ * @author Oliver Gierke
  */
-public interface ContextConsumingAggregateOperation extends AggregationOperation {
+public class GeoNearOperationUnitTests {
+
+	@Test
+	public void rendersNearQueryAsAggregationOperation() {
+
+		NearQuery query = NearQuery.near(10.0, 10.0);
+		GeoNearOperation operation = new GeoNearOperation(query);
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
 
-	/**
+		DBObject nearClause = DBObjectUtils.getAsDBObject(dbObject, "$geoNear");
-	 * Creates a {@link DBObject} representation backing this object and considers the field references from the given
+		assertThat(nearClause, is(query.toDBObject()));
-	 * {@link AggregateOperationContext}.
+	}
-	 * 
-	 * @param inputAggregateOperationContext
-	 * @return
-	 */
-	DBObject toDbObject(AggregateOperationContext inputAggregateOperationContext);
 }

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

@@ -0,0 +1,87 @@
+/*
+ * 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;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.springframework.data.mongodb.core.aggregation.Fields.*;
+
+import org.junit.Test;
+import org.springframework.data.mongodb.core.DBObjectUtils;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
+/**
+ * Unit tests for {@link GroupOperation}.
+ * 
+ * @author Oliver Gierke
+ */
+public class GroupOperationUnitTests {
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFields() {
+		new GroupOperation(null);
+	}
+
+	@Test
+	public void createsGroupOperationWithSingleField() {
+
+		GroupOperation operation = new GroupOperation(fields("a"));
+
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+		DBObject groupClause = DBObjectUtils.getAsDBObject(dbObject, "$group");
+
+		assertThat(groupClause.get(UNDERSCORE_ID), is((Object) "$a"));
+	}
+
+	@Test
+	public void createsGroupOperationWithMultipleFields() {
+
+		GroupOperation operation = new GroupOperation(fields("a").and("b", "c"));
+
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+		DBObject groupClause = DBObjectUtils.getAsDBObject(dbObject, "$group");
+		DBObject idClause = DBObjectUtils.getAsDBObject(groupClause, UNDERSCORE_ID);
+
+		assertThat(idClause.get("a"), is((Object) "$a"));
+		assertThat(idClause.get("b"), is((Object) "$c"));
+	}
+
+	@Test
+	public void shouldCreateComplexIdForGroupOperationWithSingleComplexIdField() {
+
+		// Fields fields = fields().and("a", 42);
+		// GroupOperation groupOperation = new GroupOperation(fields());
+		//
+		// assertThat(groupOperation.toDBObject(Aggregation.DEFAULT_CONTEXT), is(notNullValue()));
+		// assertThat(groupOperation.id, is(notNullValue()));
+		// assertThat(groupOperation.id, is((Object) new BasicDBObject("a", 42)));
+	}
+
+	@Test
+	public void groupFactoryMethodWithMultipleFieldsAndSumOperation() {
+
+		Fields fields = fields("a", "b").and("c"); // .and("d", 42);
+		GroupOperation groupOperation = new GroupOperation(fields).and("e").sum();
+
+		DBObject dbObject = groupOperation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+
+		DBObject groupClause = DBObjectUtils.getAsDBObject(dbObject, "$group");
+		DBObject eOp = DBObjectUtils.getAsDBObject(groupClause, "e");
+		assertThat(eOp, is((DBObject) new BasicDBObject("$sum", "$e")));
+	}
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.data.mongodb.core.DBObjectUtils;
+
+import com.mongodb.DBObject;
+
+/**
+ * Unit tests for {@link ProjectionOperation}.
+ * 
+ * @author Oliver Gierke
+ */
+public class ProjectionOperationUnitTests {
+
+	static final String PROJECT = "$project";
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullFields() {
+		new ProjectionOperation(null);
+	}
+
+	@Test
+	public void declaresBackReferenceCorrectly() {
+
+		ProjectionOperation operation = new ProjectionOperation();
+		operation = operation.and("prop").previousOperation();
+
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+		DBObject projectClause = DBObjectUtils.getAsDBObject(dbObject, PROJECT);
+		assertThat(projectClause.get("prop"), is((Object) Fields.UNDERSCORE_ID_REF));
+	}
+
+	@Test
+	public void alwaysUsesExplicitReference() {
+
+		ProjectionOperation operation = new ProjectionOperation(Fields.fields("foo").and("bar", "foobar"));
+
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+		DBObject projectClause = DBObjectUtils.getAsDBObject(dbObject, PROJECT);
+
+		assertThat(projectClause.get("foo"), is((Object) "$foo"));
+		assertThat(projectClause.get("bar"), is((Object) "$foobar"));
+	}
+}

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

@@ -1,159 +0,0 @@
-/*
- * 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;
-
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
-import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;
-
-import java.util.List;
-
-import org.junit.Test;
-import org.springframework.dao.InvalidDataAccessApiUsageException;
-
-import com.mongodb.DBObject;
-
-/**
- * Tests of {@link ProjectionOperation}.
- * 
- * @see DATAMONGO-586
- * @author Tobias Trelle
- */
-public class ProjectionTests {
-
-	@Test
-	public void emptyProjection() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project());
-		assertThat(raw.toMap().size(), is(1));
-		assertThat((Integer) raw.get("_id"), is(0));
-	}
-
-	@Test(expected = IllegalArgumentException.class)
-	public void shouldDetectNullIncludesInConstructor() {
-		new ProjectionOperation((String[]) null);
-	}
-
-	@Test
-	public void includesWithConstructor() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project("a", "b"));
-		assertThat(raw, is(notNullValue()));
-		assertThat(raw.toMap().size(), is(3));
-		assertThat((Integer) raw.get("_id"), is(0));
-		assertThat((Integer) raw.get("a"), is(1));
-		assertThat((Integer) raw.get("b"), is(1));
-	}
-
-	@Test
-	public void include() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project().include("a"));
-		assertSingleDBObject("a", 1, raw);
-	}
-
-	@Test
-	public void exclude() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project().exclude("a"));
-		assertThat(raw.toMap().size(), is(2));
-		assertThat((Integer) raw.get("_id"), is(0));
-		assertThat((Integer) raw.get("a"), is(0));
-
-	}
-
-	@Test
-	public void includeAlias() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project().include("a").as("b"));
-		assertThat(raw.toMap().size(), is(2));
-		assertThat((Integer) raw.get("_id"), is(0));
-		assertThat((String) raw.get("b"), is("$a"));
-	}
-
-	@Test(expected = InvalidDataAccessApiUsageException.class)
-	public void shouldDetectAliasWithoutInclude() {
-		project().as("b");
-	}
-
-	@Test(expected = InvalidDataAccessApiUsageException.class)
-	public void shouldDetectDuplicateAlias() {
-		project().include("a").as("b").as("c");
-	}
-
-	@Test
-	@SuppressWarnings("unchecked")
-	public void plus() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project().include("a").plus(10));
-		assertThat(raw, is(notNullValue()));
-
-		DBObject addition = (DBObject) raw.get("a");
-		assertThat(addition, is(notNullValue()));
-
-		List<Object> summands = (List<Object>) addition.get("$add");
-		assertThat(summands, is(notNullValue()));
-		assertThat(summands.size(), is(2));
-		assertThat((String) summands.get(0), is("$a"));
-		assertThat((Integer) summands.get(1), is(10));
-	}
-
-	@Test
-	@SuppressWarnings("unchecked")
-	public void plusWithAlias() {
-
-		DBObject raw = safeExtractDbObjectFromProjection(project().include("a").plus(10).as("b"));
-		assertThat(raw, is(notNullValue()));
-
-		DBObject addition = (DBObject) raw.get("b");
-		assertThat(addition, is(notNullValue()));
-
-		List<Object> summands = (List<Object>) addition.get("$add");
-		assertThat(summands, is(notNullValue()));
-		assertThat(summands.size(), is(2));
-		assertThat((String) summands.get(0), is("$a"));
-		assertThat((Integer) summands.get(1), is(10));
-	}
-
-	@Test
-	public void projectionWithFields() {
-		ProjectionOperation projectionOperation = project(ZipInfoStats.class) //
-				.field("_id", 0) //
-				.field("state", $id()) // $id() -> $_id
-				.field("biggestCity", fields().and("name", $("biggestCity")).and("population", $("biggestPop"))) //
-				.field("smallestCity", fields().and("name", $("smallestCity")).and("population", $("smallestPop")));
-
-		assertThat(projectionOperation, is(notNullValue()));
-	}
-
-	private static DBObject safeExtractDbObjectFromProjection(ProjectionOperation projectionOperation) {
-
-		assertThat(projectionOperation, is(notNullValue()));
-		DBObject dbObject = projectionOperation.toDbObject(new BasicAggregateOperationContext());
-		assertThat(dbObject, is(notNullValue()));
-		Object projection = dbObject.get("$project");
-		assertThat("Expected non null value for key $project ", projection, is(notNullValue()));
-		assertTrue("projection contents should be a " + DBObject.class.getSimpleName(), projection instanceof DBObject);
-
-		return DBObject.class.cast(projection);
-	}
-
-	private static void assertSingleDBObject(String key, Object value, DBObject doc) {
-
-		assertThat(doc, is(notNullValue()));
-		assertThat(doc.get(key), is(value));
-	}
-}

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

@@ -15,12 +15,33 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.mongodb.DBObject;
+
 /**
- * Represents one single operation in an aggregation pipeline that is aware of an {@link AggregateOperationContext} that
+ * Unit tests for {@link SkipOperation}.
- * produces an {@link AggregateOperationContext} as output.
  * 
- * @author Thomas Darimont
+ * @author Oliver Gierke
  */
-public interface ContextProducingAggregateOperation extends AggregationOperation {
+public class SkipOperationUnitTests {
-	AggregateOperationContext getOutputAggregateOperationContext();
+
+	static final String OP = "$skip";
+
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNegativeSkip() {
+		new SkipOperation(-1L);
+	}
+
+	@Test
+	public void rendersSkipOperation() {
+
+		SkipOperation operation = new SkipOperation(10L);
+		DBObject dbObject = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+
+		assertThat(dbObject.get(OP), is((Object) 10L));
+	}
 }

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

@@ -0,0 +1,56 @@
+/*
+ * 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;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.springframework.data.mongodb.core.DBObjectUtils.*;
+
+import org.junit.Test;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Direction;
+
+import com.mongodb.DBObject;
+
+/**
+ * Unit tests for {@link SortOperation}.
+ * 
+ * @author Oliver Gierke
+ */
+public class SortOperationUnitTests {
+
+	@Test
+	public void createsDBObjectForAscendingSortCorrectly() {
+
+		SortOperation operation = new SortOperation(new Sort(Direction.ASC, "foobar"));
+		DBObject result = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+
+		DBObject sortValue = getAsDBObject(result, "$sort");
+		assertThat(sortValue, is(notNullValue()));
+		assertThat(sortValue.get("foobar"), is((Object) 1));
+	}
+
+	@Test
+	public void createsDBObjectForDescendingSortCorrectly() {
+
+		SortOperation operation = new SortOperation(new Sort(Direction.DESC, "foobar"));
+		DBObject result = operation.toDBObject(Aggregation.DEFAULT_CONTEXT);
+
+		DBObject sortValue = getAsDBObject(result, "$sort");
+		assertThat(sortValue, is(notNullValue()));
+		assertThat(sortValue.get("foobar"), is((Object) (0 - 1)));
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/query/FieldUnitTests.java

@@ -21,7 +21,7 @@ import static org.junit.Assert.*;
 import org.junit.Test;
 
 /**
- * Unit tests for {@link Field}.
+ * Unit tests for {@link DocumentField}.
  * 
  * @author Oliver Gierke
  */