DATACOUCH-588 - Part 2 of framework changes. Add support for projection and distinct.

Support for projection is only for properties of the top-level entity. For
instance, in UserSubmission, only the properties below can be specified in
 the projection. Projection support does not provide means of specifying
something like address.street - you can only project (or not project) the
whole address property. However, the address type in your resultType could
have a subset of the properties in Address.

If the corresponding submissions in the resultType
contained only the userId property

public class UserSubmission extends ComparableEntity {
	private String id;
	private String username;
	private List<String> roles;
	private Address address;
	private List<Submission> submissions;

Support for Distinct - I have appropriated the MongoDB model for Distinct.
It defines a separate DistinctOperationSupport class (within
ExecutableFindByQuerySupport) which supports the distinct( distinctFields )
api and execution. The DistinctOperationSupport class has only a
distinctFields member, and a 'delegate' member, which is an
ExecutableFindByQuerySupport object. TBH, I don't see the advantage
over simply adding a distinctFields member to ExecutableFindByQuerySupport

Author: mikereiche

src/main/java/org/springframework/data/couchbase/core/ExecutableFindByQueryOperation.java

@@ -19,8 +19,10 @@
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import org.springframework.dao.DataAccessException;
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.couchbase.core.query.Query;
+import org.springframework.data.couchbase.core.query.QueryCriteriaDefinition;
 import org.springframework.lang.Nullable;
 
 import com.couchbase.client.java.query.QueryScanConsistency;
@@ -141,6 +143,125 @@ interface FindByQueryInCollection<T> extends FindByQueryConsistentWith<T> {
 
 	}
 
-	interface ExecutableFindByQuery<T> extends FindByQueryInCollection<T> {}
+	/**
+	 * Result type override (Optional).
+	 *
+	 */
+	interface FindWithProjection<T> extends FindByQueryInCollection<T>, FindDistinct {
+
+		/**
+		 * Define the target type fields should be mapped to. <br />
+		 * Skip this step if you are anyway only interested in the original domain type.
+		 *
+		 * @param resultType must not be {@literal null}.
+		 * @param <R> result type.
+		 * @return new instance of {@link FindWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> FindWithProjection<R> as(Class<R> resultType);
+
+	}
+
+	/**
+	 * Distinct Find support.
+	 *
+	 */
+	interface FindDistinct {
+
+		/**
+		 * Finds the distinct values for a specified {@literal field} across a single collection
+		 *
+		 * @param distinctFields name of the field. Must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if field is {@literal null}.
+		 */
+		TerminatingDistinct<Object> distinct(String[] distinctFields);
+
+	}
+
+	/**
+	 * Result type override. Optional.
+	 *
+	 * @author Michael Reiche
+	 */
+	interface DistinctWithProjection {
+
+		/**
+		 * Define the target type the result should be mapped to. <br />
+		 * Skip this step if you are anyway fine with the default conversion.
+		 *
+		 * @param resultType must not be {@literal null}.
+		 * @param <R> result type.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> TerminatingDistinct<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * Result restrictions. Optional.
+	 *
+	 */
+	interface DistinctWithQuery<T> extends DistinctWithProjection {
+
+		/**
+		 * Set the filter query to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingDistinct<T> matching(Query query);
+
+		/**
+		 * Set the filter {@link QueryCriteriaDefinition criteria} to be used.
+		 *
+		 * @param criteria must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if criteria is {@literal null}.
+		 */
+		default TerminatingDistinct<T> matching(QueryCriteriaDefinition criteria) {
+			return matching(Query.query(criteria));
+		}
+
+		/**
+		 * Set the  {@link QueryScanConsistency criteria} to be used.
+		 *
+		 * @param scanConsistency must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if criteria is {@literal null}.
+		 */
+		TerminatingDistinct<Object> consistentWith(QueryScanConsistency scanConsistency);
+	}
+
+	/**
+	 * Terminating distinct find operations.
+	 *
+	 */
+	interface TerminatingDistinct<T> extends DistinctWithQuery<T> {
+
+		/**
+		 * Get all matching distinct field values.
+		 *
+		 * @return empty {@link List} if not match found. Never {@literal null}.
+		 * @throws DataAccessException if eg. result cannot be converted correctly which may happen if the document contains
+		 *           {@link String} whereas the result type is specified as {@link Long}.
+		 */
+		List<T> all();
+
+		/**
+		 * Get the number of matching elements.
+		 *
+		 * @return total number of matching elements.
+		 */
+		long count();
+	}
+
+	/**
+	 * {@link ExecutableFindByQuery} provides methods for constructing lookup operations in a fluent way.
+	 *
+	 */
+
+	interface ExecutableFindByQuery<T> extends FindByQueryConsistentWith<T>, FindByQueryInCollection<T>, FindWithProjection<T>, FindDistinct  {}
 
 }

src/main/java/org/springframework/data/couchbase/core/ExecutableFindByQueryOperationSupport.java

@@ -20,6 +20,7 @@
 
 import org.springframework.data.couchbase.core.ReactiveFindByQueryOperationSupport.ReactiveFindByQuerySupport;
 import org.springframework.data.couchbase.core.query.Query;
+import org.springframework.util.Assert;
 
 import com.couchbase.client.java.query.QueryScanConsistency;
 
@@ -41,26 +42,28 @@ public ExecutableFindByQueryOperationSupport(final CouchbaseTemplate template) {
 
 	@Override
 	public <T> ExecutableFindByQuery<T> findByQuery(final Class<T> domainType) {
-		return new ExecutableFindByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED,
-				"_default._default");
+		return new ExecutableFindByQuerySupport<T>(template, domainType, domainType, ALL_QUERY,
+				QueryScanConsistency.NOT_BOUNDED, null);
 	}
 
 	static class ExecutableFindByQuerySupport<T> implements ExecutableFindByQuery<T> {
 
 		private final CouchbaseTemplate template;
-		private final Class<T> domainType;
+		private final Class<?> domainType;
+		private final Class<T> returnType;
 		private final Query query;
 		private final ReactiveFindByQuerySupport<T> reactiveSupport;
 		private final QueryScanConsistency scanConsistency;
 		private final String collection;
 
-		ExecutableFindByQuerySupport(final CouchbaseTemplate template, final Class<T> domainType, final Query query,
-				final QueryScanConsistency scanConsistency, final String collection) {
+		ExecutableFindByQuerySupport(final CouchbaseTemplate template, final Class<?> domainType, final Class<T> returnType,
+				final Query query, final QueryScanConsistency scanConsistency, final String collection) {
 			this.template = template;
 			this.domainType = domainType;
+			this.returnType = returnType;
 			this.query = query;
-			this.reactiveSupport = new ReactiveFindByQuerySupport<T>(template.reactive(), domainType, query, scanConsistency,
-					collection);
+			this.reactiveSupport = new ReactiveFindByQuerySupport<T>(template.reactive(), domainType, returnType, query,
+					scanConsistency, collection);
 			this.scanConsistency = scanConsistency;
 			this.collection = collection;
 		}
@@ -88,17 +91,31 @@ public TerminatingFindByQuery<T> matching(final Query query) {
 			} else {
 				scanCons = scanConsistency;
 			}
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanCons, collection);
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanCons, collection);
 		}
 
 		@Override
 		public FindByQueryConsistentWith<T> consistentWith(final QueryScanConsistency scanConsistency) {
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanConsistency, collection);
 		}
 
 		@Override
 		public FindByQueryInCollection<T> inCollection(final String collection) {
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanConsistency, collection);
+		}
+
+		@Override
+		public <R> FindWithProjection<R> as(Class<R> returnType) {
+			Assert.notNull(returnType, "returnType must not be null!");
+
+			return new ExecutableFindByQuerySupport<R>(template, domainType, returnType, query, scanConsistency, collection);
+		}
+
+		@Override
+		public TerminatingDistinct<Object> distinct(String[] distinctFields) {
+
+			Assert.notNull(distinctFields, "distinctFields must not be null!");
+			return new DistinctOperationSupport(this, distinctFields);
 		}
 
 		@Override
@@ -115,7 +132,83 @@ public long count() {
 		public boolean exists() {
 			return count() > 0;
 		}
+	}
+
+	/**
+	 * @author Michael Reiche
+	 */
+	static class DistinctOperationSupport<T> implements TerminatingDistinct<T> {
+
+		private final String[] distinctFields;
+		private final ExecutableFindByQuerySupport<T> delegate;
+
+		public DistinctOperationSupport(ExecutableFindByQuerySupport<T> delegate, String[] distinctFields) {
+
+			this.delegate = delegate;
+			this.distinctFields = distinctFields;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public <R> TerminatingDistinct<R> as(Class<R> resultType) {
+
+			Assert.notNull(resultType, "resultType must not be null!");
+
+			return new DistinctOperationSupport<>((ExecutableFindByQuerySupport) delegate.as(resultType), distinctFields);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingDistinct<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new DistinctOperationSupport<>((ExecutableFindByQuerySupport<T>) delegate.matching(query), distinctFields);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public TerminatingDistinct<Object> consistentWith(QueryScanConsistency scanConsistency) {
+
+			Assert.notNull(scanConsistency, "scanConsistency must not be null!");
+
+			return new DistinctOperationSupport<>((ExecutableFindByQuerySupport) delegate.consistentWith(scanConsistency),
+					distinctFields);
+		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingDistinct#all()
+		 */
+		@Override
+		public List<T> all() {
+			ReactiveFindByQueryOperationSupport.TerminatingDistinct<T> query = delegate.reactiveSupport
+					.distinct(distinctFields).as(delegate.returnType);
+			return query.all().collectList().block();
+		}
+
+		/**
+		 * Get the number of matching elements.
+		 *
+		 * @return total number of matching elements.
+		 */
+		@Override
+		public long count() {
+			ReactiveFindByQueryOperationSupport.TerminatingDistinct<T> query = delegate.reactiveSupport
+					.distinct(distinctFields).as(delegate.returnType);
+			return query.count().block();
+		}
 	}
 
 }