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

Amend #1 - changes as discussed in Pull Request
         - clean up test entity types

Amend #2
- Eliminate DistinctOperationSupport class. In MongoDB, only distinct on
a single field is supported, so the returnType from distinct was very
different from the returnType of other query operations (all(), one()
etc. (but so is count(), and it doesn't need it's own class)). In
Couchbase, distinct on any fields in the entity is allowed - so the
returned type could be the domainType or resultType. And as(resultType)
still allows any resultType to be specified. This makes it unnecessary
to have combinations of interfaces such as DistinctWithProjection and
DistinctWithQuery.

- Clean up the interfaces in ExecutableFindByQuery. There are two types
of interfaces (a) the TerminatingFindByQuery which has the one(), oneValue()
first(), firstValue(), all(), count(), exists() and stream(); and
(b) the option interfaces (FindByQueryWithConsistency etc), which are
essentially with-er interfaces. The changes are:
1) make all the with-er interfaces base interfaces instead of chaining them
together. (I don't know why there isn't simply one interface with all the
with-er methods).
2) make the ExecutableFindByQuery interface extend the Terminating interface
and all the with-er interfaces.

Author: mikereiche

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

@@ -21,6 +21,7 @@
 
 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;
@@ -107,40 +108,90 @@ default Optional<T> first() {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindByQueryWithQuery<T> extends TerminatingFindByQuery<T> {
+	interface FindByQueryWithQuery<T> {
 
 		/**
 		 * Set the filter for the query to be used.
 		 *
 		 * @param query must not be {@literal null}.
 		 * @throws IllegalArgumentException if query is {@literal null}.
 		 */
-		TerminatingFindByQuery<T> matching(Query query);
+		ExecutableFindByQuery<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 ExecutableFindByQuery}.
+		 * @throws IllegalArgumentException if criteria is {@literal null}.
+		 */
+		default ExecutableFindByQuery<T> matching(QueryCriteriaDefinition criteria) {
+			return matching(Query.query(criteria));
+		}
 
 	}
 
-	interface FindByQueryConsistentWith<T> extends FindByQueryWithQuery<T> {
+	interface FindByQueryConsistentWith<T> {
 
 		/**
 		 * Allows to override the default scan consistency.
 		 *
 		 * @param scanConsistency the custom scan consistency to use for this query.
 		 */
-		FindByQueryConsistentWith<T> consistentWith(QueryScanConsistency scanConsistency);
+		ExecutableFindByQuery<T> consistentWith(QueryScanConsistency scanConsistency);
 
 	}
 
-	interface FindByQueryInCollection<T> extends FindByQueryConsistentWith<T> {
+	interface FindByQueryInCollection<T> {
 
 		/**
 		 * Allows to override the default scan consistency.
 		 *
 		 * @param collection the collection to use for this query.
 		 */
-		FindByQueryInCollection<T> inCollection(String collection);
+		ExecutableFindByQuery<T> inCollection(String collection);
+
+	}
+
+	/**
+	 * Result type override (Optional).
+	 */
+	interface FindByQueryWithProjection<T> {
+
+		/**
+		 * 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 FindByQueryWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> ExecutableFindByQuery<R> as(Class<R> resultType);
 
 	}
 
-	interface ExecutableFindByQuery<T> extends FindByQueryInCollection<T> {}
+	/**
+	 * Distinct Find support.
+	 */
+	interface FindByQueryDistinct<T> {
+
+		/**
+		 * 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 ExecutableFindByQuery}.
+		 * @throws IllegalArgumentException if field is {@literal null}.
+		 */
+		ExecutableFindByQuery<T> distinct(String[] distinctFields);
+
+	}
+
+	/**
+	 * {@link ExecutableFindByQuery} provides methods for constructing lookup operations in a fluent way.
+	 */
+
+	interface ExecutableFindByQuery<T> extends TerminatingFindByQuery<T>, FindByQueryWithQuery<T>,
+			FindByQueryConsistentWith<T>, FindByQueryInCollection<T>, FindByQueryWithProjection<T>, FindByQueryDistinct<T> {}
 
 }

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,28 +42,33 @@ 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, 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;
+		private final String[] distinctFields;
 
-		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,
+				final String[] distinctFields) {
 			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, distinctFields);
 			this.scanConsistency = scanConsistency;
 			this.collection = collection;
+			this.distinctFields = distinctFields;
 		}
 
 		@Override
@@ -81,24 +87,42 @@ public List<T> all() {
 		}
 
 		@Override
-		public TerminatingFindByQuery<T> matching(final Query query) {
+		public ExecutableFindByQuery<T> matching(final Query query) {
 			QueryScanConsistency scanCons;
 			if (query.getScanConsistency() != null) {
 				scanCons = query.getScanConsistency();
 			} else {
 				scanCons = scanConsistency;
 			}
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanCons, collection);
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanCons, collection,
+					distinctFields);
 		}
 
 		@Override
-		public FindByQueryConsistentWith<T> consistentWith(final QueryScanConsistency scanConsistency) {
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		public ExecutableFindByQuery<T> consistentWith(final QueryScanConsistency scanConsistency) {
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanConsistency, collection,
+					distinctFields);
 		}
 
 		@Override
-		public FindByQueryInCollection<T> inCollection(final String collection) {
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		public ExecutableFindByQuery<T> inCollection(final String collection) {
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanConsistency, collection,
+					distinctFields);
+		}
+
+		@Override
+		public <R> ExecutableFindByQuery<R> as(Class<R> returnType) {
+			Assert.notNull(returnType, "returnType must not be null!");
+
+			return new ExecutableFindByQuerySupport<R>(template, domainType, returnType, query, scanConsistency, collection,
+					distinctFields);
+		}
+
+		@Override
+		public ExecutableFindByQuery<T> distinct(String[] distinctFields) {
+			Assert.notNull(distinctFields, "distinctFields must not be null!");
+			return new ExecutableFindByQuerySupport<>(template, domainType, returnType, query, scanConsistency, collection,
+					distinctFields);
 		}
 
 		@Override
@@ -115,7 +139,6 @@ public long count() {
 		public boolean exists() {
 			return count() > 0;
 		}
-
 	}
 
 }