GH-2243 - Add support for distinct derived queries.

Closes #2243

Author: meistermeier

src/main/java/org/springframework/data/neo4j/repository/query/CypherQueryCreator.java

@@ -85,6 +85,7 @@ final class CypherQueryCreator extends AbstractQueryCreator<QueryFragmentsAndPar
 	private final NodeDescription<?> nodeDescription;
 
 	private final Neo4jQueryType queryType;
+	private final boolean isDistinct;
 
 	private final Iterator<Neo4jQueryMethod.Neo4jParameter> formalParameters;
 	private final Queue<Parameter> lastParameter = new LinkedList<>();
@@ -127,6 +128,7 @@ final class CypherQueryCreator extends AbstractQueryCreator<QueryFragmentsAndPar
 		this.nodeDescription = this.mappingContext.getRequiredNodeDescription(this.domainType);
 
 		this.queryType = queryType;
+		this.isDistinct = tree.isDistinct();
 
 		this.formalParameters = actualParameters.getParameters().iterator();
 		this.maxResults = tree.isLimiting() ? tree.getMaxResults() : null;
@@ -293,7 +295,7 @@ private QueryFragmentsAndParameters.QueryFragments createQueryFragments(@Nullabl
 		} else if (queryType == Neo4jQueryType.EXISTS) {
 			queryFragments.setReturnExpression(Functions.count(Constants.NAME_OF_ROOT_NODE).gt(Cypher.literalOf(0)), true);
 		} else {
-			queryFragments.setReturnBasedOn(nodeDescription, includedProperties);
+			queryFragments.setReturnBasedOn(nodeDescription, includedProperties, isDistinct);
 			queryFragments.setOrderBy(Stream
 					.concat(sortItems.stream(),
 							pagingParameter.getSort().and(sort).stream().map(CypherAdapterUtils.sortAdapterFor(nodeDescription)))

src/main/java/org/springframework/data/neo4j/repository/query/QueryFragmentsAndParameters.java

@@ -280,8 +280,8 @@ public void setSkip(Long skip) {
 			this.skip = skip;
 		}
 
-		public void setReturnBasedOn(NodeDescription<?> nodeDescription, List<String> includedProperties) {
-			this.returnTuple = new ReturnTuple(nodeDescription, includedProperties);
+		public void setReturnBasedOn(NodeDescription<?> nodeDescription, List<String> includedProperties, boolean isDistinct) {
+			this.returnTuple = new ReturnTuple(nodeDescription, includedProperties, isDistinct);
 		}
 
 		public ReturnTuple getReturnTuple() {
@@ -300,17 +300,6 @@ public void setRenderConstantsAsParameters(boolean renderConstantsAsParameters)
 			this.renderConstantsAsParameters = renderConstantsAsParameters;
 		}
 
-		private Expression[] getReturnExpressions() {
-			return returnExpressions.size() > 0
-					? returnExpressions.toArray(new Expression[]{})
-					: CypherGenerator.INSTANCE.createReturnStatementForMatch(getReturnTuple().nodeDescription,
-					this::includeField);
-		}
-
-		private SortItem[] getOrderBy() {
-			return orderBy != null ? orderBy : new SortItem[]{};
-		}
-
 		public Statement generateGenericStatement() {
 			String rootNodeIds = "rootNodeIds";
 			String relationshipIds = "relationshipIds";
@@ -350,26 +339,48 @@ public Statement toStatement() {
 				}
 			}
 
-			Statement statement = match
-				.where(condition)
-				.returning(getReturnExpressions())
-				.orderBy(getOrderBy())
-				.skip(skip)
-				.limit(limit).build();
+			StatementBuilder.OngoingReadingWithWhere matchWithWhere = match.where(condition);
+
+			StatementBuilder.OngoingReadingAndReturn returnPart = isDistinctReturn()
+					? matchWithWhere.returningDistinct(getReturnExpressions())
+					: matchWithWhere.returning(getReturnExpressions());
+
+			Statement statement = returnPart
+					.orderBy(getOrderBy())
+					.skip(skip)
+					.limit(limit).build();
+
 			statement.setRenderConstantsAsParameters(renderConstantsAsParameters);
 			return statement;
 		}
 
+		private Expression[] getReturnExpressions() {
+			return returnExpressions.size() > 0
+					? returnExpressions.toArray(new Expression[]{})
+					: CypherGenerator.INSTANCE.createReturnStatementForMatch(getReturnTuple().nodeDescription,
+					this::includeField);
+		}
+
+		private boolean isDistinctReturn() {
+			return returnExpressions.isEmpty() && getReturnTuple().isDistinct;
+		}
+
+		private SortItem[] getOrderBy() {
+			return orderBy != null ? orderBy : new SortItem[]{};
+		}
+
 		/**
 		 * Describes which fields of an entity needs to get returned.
 		 */
 		final static class ReturnTuple {
 			final NodeDescription<?> nodeDescription;
 			final Set<String> includedProperties;
+			final boolean isDistinct;
 
-			private ReturnTuple(NodeDescription<?> nodeDescription, List<String> includedProperties) {
+			private ReturnTuple(NodeDescription<?> nodeDescription, List<String> includedProperties, boolean isDistinct) {
 				this.nodeDescription = nodeDescription;
 				this.includedProperties = includedProperties == null ? Collections.emptySet() : new HashSet<>(includedProperties);
+				this.isDistinct = isDistinct;
 			}
 		}
 	}

src/test/java/org/springframework/data/neo4j/integration/imperative/RepositoryIT.java

@@ -3806,6 +3806,16 @@ void findByPropertyOnRelatedEntityOfRelatedSameEntity(@Autowired RelationshipRep
 			assertThat(repository.findByPetsFriendsName("Jerry")).isNull();
 		}
 
+		@Test // GH-2243
+		void findDistinctByRelatedEntity(@Autowired RelationshipRepository repository) {
+			doWithSession(session ->
+					session.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(:Hobby{name: 'Music'})"
+							+ "CREATE (n)-[:Has]->(:Hobby{name: 'Music'})").consume());
+
+			assertThat(repository.findDistinctByHobbiesName("Music")).isNotNull();
+
+		}
+
 		@Test
 		void findByPropertyOnRelationshipWithProperties(@Autowired PersonWithRelationshipWithPropertiesRepository repository) {
 			doWithSession(session ->
@@ -4002,6 +4012,8 @@ interface RelationshipRepository extends Neo4jRepository<PersonWithRelationship,
 			   + "}\n"
 			   + "RETURN n, collect(r), collect(p)")
 		PersonWithRelationship createWithCustomQuery(PersonWithRelationship p);
+
+		PersonWithRelationship.PersonWithHobby findDistinctByHobbiesName(String hobbyName);
 	}
 
 	interface SimilarThingRepository extends Neo4jRepository<SimilarThing, Long> {}

src/test/java/org/springframework/data/neo4j/integration/reactive/ReactiveRepositoryIT.java

@@ -1303,6 +1303,17 @@ void findByPropertyOnRelatedEntityOfRelatedSameEntity(@Autowired ReactiveRelatio
 			StepVerifier.create(repository.findByPetsFriendsName("Jerry")).verifyComplete();
 		}
 
+		@Test // GH-2243
+		void findDistinctByRelatedEntity(@Autowired ReactiveRelationshipRepository repository) {
+			doWithSession(session ->
+				session.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(:Hobby{name: 'Music'})"
+						+ "CREATE (n)-[:Has]->(:Hobby{name: 'Music'})").consume());
+
+			StepVerifier.create(repository.findDistinctByHobbiesName("Music"))
+					.assertNext(person -> assertThat(person).isNotNull())
+					.verifyComplete();
+		}
+
 		@Test
 		void findByPropertyOnRelationshipWithProperties(
 				@Autowired ReactivePersonWithRelationshipWithPropertiesRepository repository) {
@@ -2513,6 +2524,8 @@ interface ReactiveRelationshipRepository extends ReactiveNeo4jRepository<PersonW
 		Mono<PersonWithRelationship> findByPetsFriendsName(String petName);
 
 		Flux<PersonWithRelationship> findByName(String name, Sort sort);
+
+		Mono<PersonWithRelationship.PersonWithHobby> findDistinctByHobbiesName(String hobbyName);
 	}
 
 	interface ReactiveSimilarThingRepository extends ReactiveCrudRepository<SimilarThing, Long> {}

src/test/java/org/springframework/data/neo4j/integration/shared/common/PersonWithRelationship.java

@@ -77,4 +77,12 @@ public List<Pet> getPets() {
 	public void setPets(List<Pet> pets) {
 		this.pets = pets;
 	}
+
+	/**
+	 * Simple person with hobbies relationship to enforce non-cyclic querying.
+	 */
+	public interface PersonWithHobby {
+		String getName();
+		Hobby getHobbies();
+	}
 }