DATAMONGO-1585 - Expose synthetic fields in $project aggregation stage.

Field projections now expose their fields as synthetic simple fields. Projection aggregation stage redefines the available field set available for later aggregation stages entirely so projected fields are considered synthetic. A simple synthetic field has no target field which causes later aggregation stages to not pick up the underlying target but the exposed field name when rendering aggregation operations to Mongo documents.

The change is motivated by a bug where previously an aggregation consisting of projection of an aliased field and sort caused the sort projection stage to render with the original field name instead of the aliased field. The sort did not apply any sorting since projection redefines the available field set entirely and the original field is no longer accessible.

Original Pull Request: #433

Author: mp911de

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2016 the original author or authors.
+ * Copyright 2013-2017 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.
@@ -28,6 +28,7 @@
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
 import org.springframework.data.mongodb.core.aggregation.Fields.AggregationField;
 import org.springframework.data.mongodb.core.aggregation.ProjectionOperation.ProjectionOperationBuilder.FieldProjection;
+import org.springframework.data.mongodb.core.aggregation.VariableOperators.Let.ExpressionVariable;
 import org.springframework.util.Assert;
 
 /**
@@ -1206,8 +1207,9 @@ public ProjectionOperationBuilder dateAsFormattedString(String format) {
 		 * @since 1.10
 		 */
 		public ProjectionOperationBuilder let(AggregationExpression valueExpression, String variableName,
-											  AggregationExpression in) {
-			return this.operation.and(VariableOperators.Let.define(ExpressionVariable.newVariable(variableName).forExpression(valueExpression)).andApply(in));
+				AggregationExpression in) {
+			return this.operation.and(VariableOperators.Let
+					.define(ExpressionVariable.newVariable(variableName).forExpression(valueExpression)).andApply(in));
 		}
 
 		/**
@@ -1279,6 +1281,7 @@ public Document toDocument(AggregationOperationContext context) {
 		 * 
 		 * @author Oliver Gierke
 		 * @author Thomas Darimont
+		 * @author Mark Paluch
 		 */
 		static class FieldProjection extends Projection {
 
@@ -1297,7 +1300,7 @@ public FieldProjection(String name, Object value) {
 
 			private FieldProjection(Field field, Object value) {
 
-				super(field);
+				super(new ExposedField(field.getName(), true));
 
 				this.field = field;
 				this.value = value;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2016 the original author or authors.
+ * Copyright 2013-2017 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.
@@ -33,6 +33,7 @@
 import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.mongodb.core.aggregation.ConditionalOperators.Cond;
 import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.test.util.BasicDbListBuilder;
 
 /**
  * Unit tests for {@link Aggregation}.
@@ -279,6 +280,47 @@ public void shouldSupportReferingToNestedPropertiesInGroupOperation() {
 		assertThat(id.get("ruleType"), is((Object) "$rules.ruleType"));
 	}
 
+	/**
+	 * @see DATAMONGO-1585
+	 */
+	@Test
+	public void shouldSupportSortingBySyntheticAndExposedGroupFields() {
+
+		Document agg = newAggregation( //
+				group("cmsParameterId").addToSet("title").as("titles"), //
+				sort(Direction.ASC, "cmsParameterId", "titles") //
+		).toDocument("foo", Aggregation.DEFAULT_CONTEXT);
+
+		assertThat(agg, is(notNullValue()));
+
+		Document sort = ((List<Document>) agg.get("pipeline")).get(1);
+
+		assertThat(getAsDocument(sort, "$sort"), is(Document.parse("{ \"_id.cmsParameterId\" : 1 , \"titles\" : 1}")));
+	}
+
+	/**
+	 * @see DATAMONGO-1585
+	 */
+	@Test
+	public void shouldSupportSortingByProjectedFields() {
+
+		Document agg = newAggregation( //
+				project("cmsParameterId") //
+						.and(SystemVariable.CURRENT + ".titles").as("titles") //
+						.and("field").as("alias"), //
+				sort(Direction.ASC, "cmsParameterId", "titles", "alias") //
+		).toDocument("foo", Aggregation.DEFAULT_CONTEXT);
+
+		assertThat(agg, is(notNullValue()));
+
+		Document sort = ((List<Document>) agg.get("pipeline")).get(1);
+
+		assertThat(getAsDocument(sort, "$sort"),
+				isBsonObject().containing("cmsParameterId", 1) //
+						.containing("titles", 1) //
+						.containing("alias", 1));
+	}
+
 	/**
 	 * @see DATAMONGO-924
 	 */
@@ -336,7 +378,7 @@ public void shouldRenderAggregationWithCustomOptionsCorrectly() {
 	}
 
 	/**
-	 * @see DATAMONGO-954
+	 * @see DATAMONGO-954, DATAMONGO-1585
 	 */
 	@Test
 	public void shouldSupportReferencingSystemVariables() {
@@ -345,15 +387,15 @@ public void shouldSupportReferencingSystemVariables() {
 				project("someKey") //
 						.and("a").as("a1") //
 						.and(Aggregation.CURRENT + ".a").as("a2") //
-				, sort(Direction.DESC, "a") //
+				, sort(Direction.DESC, "a1") //
 				, group("someKey").first(Aggregation.ROOT).as("doc") //
 		).toDocument("foo", Aggregation.DEFAULT_CONTEXT);
 
 		Document projection0 = extractPipelineElement(agg, 0, "$project");
 		assertThat(projection0, is((Document) new Document("someKey", 1).append("a1", "$a").append("a2", "$$CURRENT.a")));
 
 		Document sort = extractPipelineElement(agg, 1, "$sort");
-		assertThat(sort, is((Document) new Document("a", -1)));
+		assertThat(sort, is((Document) new Document("a1", -1)));
 
 		Document group = extractPipelineElement(agg, 2, "$group");
 		assertThat(group, is((Document) new Document("_id", "$someKey").append("doc", new Document("$first", "$$ROOT"))));

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2016 the original author or authors.
+ * Copyright 2013-2017 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.
@@ -103,7 +103,8 @@ public void returnsReferencesToNestedFieldsCorrectly() {
 	public void aliasesIdFieldCorrectly() {
 
 		AggregationOperationContext context = getContext(Foo.class);
-		assertThat(context.getReference("id"), is((FieldReference) new DirectFieldReference(new ExposedField(field("id", "_id"), true))));
+		assertThat(context.getReference("id"),
+				is((FieldReference) new DirectFieldReference(new ExposedField(field("id", "_id"), true))));
 	}
 
 	/**
@@ -173,6 +174,23 @@ public void rendersAggregationOptionsInTypedAggregationContextCorrectly() {
 		assertThat(document.get("cursor"), is((Object) new org.bson.Document("foo", 1)));
 	}
 
+	/**
+	 * @see DATAMONGO-1585
+	 */
+	@Test
+	public void rendersSortOfProjectedFieldCorrectly() {
+
+		TypeBasedAggregationOperationContext context = getContext(MeterData.class);
+		TypedAggregation<MeterData> agg = newAggregation(MeterData.class, project().and("counterName").as("counter"), //
+				sort(Direction.ASC, "counter"));
+
+		Document dbo = agg.toDocument("meterData", context);
+		Document sort = getPipelineElementFromAggregationAt(dbo, 1);
+
+		Document definition = (Document) sort.get("$sort");
+		assertThat(definition.get("counter"), is(equalTo((Object) 1)));
+	}
+
 	/**
 	 * @see DATAMONGO-1133
 	 */
@@ -192,21 +210,23 @@ public void shouldHonorAliasedFieldsInGroupExpressions() {
 	}
 
 	/**
-	 * @see DATAMONGO-1326
+	 * @see DATAMONGO-1326, DATAMONGO-1585
 	 */
 	@Test
 	public void lookupShouldInheritFieldsFromInheritingAggregationOperation() {
 
 		TypeBasedAggregationOperationContext context = getContext(MeterData.class);
 		TypedAggregation<MeterData> agg = newAggregation(MeterData.class,
-				lookup("OtherCollection", "resourceId", "otherId", "lookup"), sort(Direction.ASC, "resourceId"));
+				lookup("OtherCollection", "resourceId", "otherId", "lookup"), //
+				sort(Direction.ASC, "resourceId", "counterName"));
 
 		org.bson.Document document = agg.toDocument("meterData", context);
 		org.bson.Document sort = getPipelineElementFromAggregationAt(document, 1);
 
 		org.bson.Document definition = (org.bson.Document) sort.get("$sort");
 
 		assertThat(definition.get("resourceId"), is(equalTo((Object) 1)));
+		assertThat(definition.get("counter_name"), is(equalTo((Object) 1)));
 	}
 
 	/**

src/main/asciidoc/reference/mongodb.adoc

@@ -1734,8 +1734,8 @@ Note that the aggregation operations not listed here are currently not supported
 [[mongo.aggregation.projection]]
 === Projection Expressions
 
-Projection expressions are used to define the fields that are the outcome of a particular aggregation step. Projection expressions can be defined via the `project` method of the `Aggregate` class either by passing a list of `String` 's or an aggregation framework `Fields` object. The projection can be extended with additional fields through a fluent API via the `and(String)` method and aliased via the `as(String)` method.
-Note that one can also define fields with aliases via the static factory method `Fields.field` of the aggregation framework that can then be used to construct a new `Fields` instance.
+Projection expressions are used to define the fields that are the outcome of a particular aggregation step. Projection expressions can be defined via the `project` method of the `Aggregate` class either by passing a list of ``String``'s or an aggregation framework `Fields` object. The projection can be extended with additional fields through a fluent API via the `and(String)` method and aliased via the `as(String)` method.
+Note that one can also define fields with aliases via the static factory method `Fields.field` of the aggregation framework that can then be used to construct a new `Fields` instance. References to projected fields in later aggregation stages are only valid by using the field name of included fields or their alias of aliased or newly defined fields. Fields not included in the projection cannot be referenced in later aggregation stages.
 
 .Projection expression examples
 ====
@@ -1747,9 +1747,19 @@ project("a","b").and("foo").as("bar") // will generate {$project: {a: 1, b: 1, b
 ----
 ====
 
-Note that more examples for project operations can be found in the `AggregationTests` class.
+.Multi-Stage Aggregation using Projection and Sorting
+====
+[source,java]
+----
+project("name", "netPrice"), sort(ASC, "name") // will generate {$project: {name: 1, netPrice: 1}}, {$sort: {name: 1}}
+
+project().and("foo").as("bar"), sort(ASC, "bar") // will generate {$project: {bar: $foo}}, {$sort: {bar: 1}}
+
+project().and("foo").as("bar"), sort(ASC, "foo") // this will not work
+----
+====
 
-Note that further details regarding the projection expressions can be found in the http://docs.mongodb.org/manual/reference/operator/aggregation/project/#pipe._S_project[corresponding section] of the MongoDB Aggregation Framework reference documentation.
+More examples for project operations can be found in the `AggregationTests` class. Note that further details regarding the projection expressions can be found in the http://docs.mongodb.org/manual/reference/operator/aggregation/project/#pipe._S_project[corresponding section] of the MongoDB Aggregation Framework reference documentation.
 
 [[mongo.aggregation.projection.expressions]]
 ==== Spring Expression Support in Projection Expressions
@@ -1922,7 +1932,7 @@ ZipInfoStats firstZipInfoStats = result.getMappedResults().get(0);
 
 * The class `ZipInfo` maps the structure of the given input-collection. The class `ZipInfoStats` defines the structure in the desired output format.
 * As a first step we use the `group` operation to define a group from the input-collection. The grouping criteria is the combination of the fields `"state"` and `"city"` which forms the id structure of the group. We aggregate the value of the `"population"` property from the grouped elements with by using the `sum` operator saving the result in the field `"pop"`.
-* In a second step we use the `sort` operation to sort the intermediate-result by the fields `"pop"`, `"state"` and `"city"` in ascending order, such that the smallest city is at the top and the biggest city is at the bottom of the result. Note that the sorting on "state" and `"city"` is implicitly performed against the group id fields which Spring Data MongoDB took care of.
+* In a second step we use the `sort` operation to sort the intermediate-result by the fields `"pop"`, `"state"` and `"city"` in ascending order, such that the smallest city is at the top and the biggest city is at the bottom of the result. Note that the sorting on `"state"` and `"city"` is implicitly performed against the group id fields which Spring Data MongoDB took care of.
 * In the third step we use a `group` operation again to group the intermediate result by `"state"`. Note that `"state"` again implicitly references an group-id field. We select the name and the population count of the biggest and smallest city with calls to the `last(…)` and `first(...)` operator respectively via the `project` operation.
 * As the forth step we select the `"state"` field from the previous `group` operation. Note that `"state"` again implicitly references an group-id field. As we do not want an implicitly generated id to appear, we exclude the id from the previous operation via `and(previousOperation()).exclude()`. As we want to populate the nested `City` structures in our output-class accordingly we have to emit appropriate sub-documents with the nested method.
 * Finally as the fifth step we sort the resulting list of `StateStats` by their state name in ascending order via the `sort` operation.