Merge branch 'datacouch_588_refactoring_part_1' of github.com:spring-projects/spring-data-couchbase

Author: mikereiche

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

@@ -130,6 +130,17 @@ interface FindByQueryConsistentWith<T> extends FindByQueryWithQuery<T> {
 
 	}
 
-	interface ExecutableFindByQuery<T> extends FindByQueryConsistentWith<T> {}
+	interface FindByQueryInCollection<T> extends FindByQueryConsistentWith<T> {
+
+		/**
+		 * Allows to override the default scan consistency.
+		 *
+		 * @param collection the collection to use for this query.
+		 */
+		FindByQueryInCollection<T> inCollection(String collection);
+
+	}
+
+	interface ExecutableFindByQuery<T> extends FindByQueryInCollection<T> {}
 
 }

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

@@ -23,6 +23,12 @@
 import com.couchbase.client.java.query.QueryScanConsistency;
 import org.springframework.data.couchbase.core.ReactiveFindByQueryOperationSupport.ReactiveFindByQuerySupport;
 
+/**
+ * {@link ExecutableFindByQueryOperation} implementations for Couchbase.
+ *
+ * @author Michael Nitschinger
+ * @author Michael Reiche
+ */
 public class ExecutableFindByQueryOperationSupport implements ExecutableFindByQueryOperation {
 
 	private static final Query ALL_QUERY = new Query();
@@ -35,7 +41,7 @@ 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);
+		return new ExecutableFindByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED, null);
 	}
 
 	static class ExecutableFindByQuerySupport<T> implements ExecutableFindByQuery<T> {
@@ -45,14 +51,16 @@ static class ExecutableFindByQuerySupport<T> implements ExecutableFindByQuery<T>
 		private final Query query;
 		private final ReactiveFindByQueryOperationSupport.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 QueryScanConsistency scanConsistency, final String collection) {
 			this.template = template;
 			this.domainType = domainType;
 			this.query = query;
-			this.reactiveSupport = new ReactiveFindByQuerySupport<T>(template.reactive(), domainType, query, scanConsistency);
+			this.reactiveSupport = new ReactiveFindByQuerySupport<T>(template.reactive(), domainType, query, scanConsistency, collection);
 			this.scanConsistency = scanConsistency;
+			this.collection = collection;
 		}
 
 		@Override
@@ -78,12 +86,17 @@ public TerminatingFindByQuery<T> matching(final Query query) {
 			} else {
 				scanCons = scanConsistency;
 			}
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanCons);
+			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanCons, collection);
 		}
 
 		@Override
 		public FindByQueryConsistentWith<T> consistentWith(final QueryScanConsistency scanConsistency) {
-			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		}
+
+		@Override
+		public FindByQueryInCollection<T> inCollection(final String collection) {
+			return new ExecutableFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
 		}
 
 		@Override

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

@@ -43,6 +43,12 @@ interface RemoveByQueryConsistentWith<T> extends RemoveByQueryWithQuery<T> {
 
 	}
 
-	interface ExecutableRemoveByQuery<T> extends RemoveByQueryConsistentWith<T> {}
+	interface RemoveByQueryInCollection<T> extends RemoveByQueryConsistentWith<T> {
+
+		RemoveByQueryConsistentWith<T> inCollection(String collection);
+
+	}
+
+	interface ExecutableRemoveByQuery<T> extends RemoveByQueryInCollection<T> {}
 
 }

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

@@ -33,7 +33,7 @@ public ExecutableRemoveByQueryOperationSupport(final CouchbaseTemplate template)
 
 	@Override
 	public <T> ExecutableRemoveByQuery<T> removeByQuery(Class<T> domainType) {
-		return new ExecutableRemoveByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED);
+		return new ExecutableRemoveByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED, null);
 	}
 
 	static class ExecutableRemoveByQuerySupport<T> implements ExecutableRemoveByQuery<T> {
@@ -43,15 +43,17 @@ static class ExecutableRemoveByQuerySupport<T> implements ExecutableRemoveByQuer
 		private final Query query;
 		private final ReactiveRemoveByQueryOperationSupport.ReactiveRemoveByQuerySupport<T> reactiveSupport;
 		private final QueryScanConsistency scanConsistency;
+		private final String collection;
 
 		ExecutableRemoveByQuerySupport(final CouchbaseTemplate template, final Class<T> domainType, final Query query,
-				final QueryScanConsistency scanConsistency) {
+				final QueryScanConsistency scanConsistency, String collection) {
 			this.template = template;
 			this.domainType = domainType;
 			this.query = query;
 			this.reactiveSupport = new ReactiveRemoveByQueryOperationSupport.ReactiveRemoveByQuerySupport<>(
 					template.reactive(), domainType, query, scanConsistency);
 			this.scanConsistency = scanConsistency;
+			this.collection = collection;
 		}
 
 		@Override
@@ -61,12 +63,16 @@ public List<RemoveResult> all() {
 
 		@Override
 		public TerminatingRemoveByQuery<T> matching(final Query query) {
-			return new ExecutableRemoveByQuerySupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableRemoveByQuerySupport<>(template, domainType, query, scanConsistency, collection);
 		}
 
 		@Override
 		public RemoveByQueryWithQuery<T> consistentWith(final QueryScanConsistency scanConsistency) {
-			return new ExecutableRemoveByQuerySupport<>(template, domainType, query, scanConsistency);
+			return new ExecutableRemoveByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		}
+		@Override
+		public RemoveByQueryInCollection<T> inCollection(final String collection) {
+			return new ExecutableRemoveByQuerySupport<>(template, domainType, query, scanConsistency, collection);
 		}
 
 	}

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

@@ -15,14 +15,20 @@
  */
 package org.springframework.data.couchbase.core;
 
-import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.couchbase.core.query.Query;
 
 import com.couchbase.client.java.query.QueryScanConsistency;
 
+/**
+ * ReactiveFindByQueryOperation
+ *
+ * @author Michael Nitschinger
+ * @author Michael Reiche
+ */
 public interface ReactiveFindByQueryOperation {
 
 	/**
@@ -104,6 +110,124 @@ interface FindByQueryConsistentWith<T> extends FindByQueryWithQuery<T> {
 
 	}
 
-	interface ReactiveFindByQuery<T> extends FindByQueryConsistentWith<T> {}
+	/**
+	 * Collection override (optional).
+	 */
+	interface FindInCollection<T> extends FindByQueryWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query on. <br />
+		 * Skip this step to use the default collection derived from the domain type.
+		 *
+		 * @param collection must not be {@literal null} nor {@literal empty}.
+		 * @return new instance of {@link FindWithProjection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		FindInCollection<T> inCollection(String collection);
+	}
+
+	/**
+	 * Result type override (optional).
+	 */
+	interface FindWithProjection<T> extends FindInCollection<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> FindByQueryWithQuery<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * Distinct Find support.
+	 *
+ 	 * @author Michael Reiche
+	 */
+	interface FindDistinct {
+
+		/**
+		 * Finds the distinct values for a specified {@literal field} across a single {@link } or view.
+		 *
+		 * @param field 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 field);
+	}
+
+	/**
+	 * 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.
+		 * <dl>
+		 * <dt>{@link Object} (the default)</dt>
+		 * <dd>Result is mapped according to the {@link } converting eg. {@link } into plain {@link String}, {@link } to
+		 * {@link Long}, etc. always picking the most concrete type with respect to the domain types property.<br />
+		 * Any {@link } is run through the {@link org.springframework.data.convert.EntityReader} to obtain the domain type.
+		 * <br />
+		 * Using {@link Object} also works for non strictly typed fields. Eg. a mixture different types like fields using
+		 * {@link String} in one {@link } while {@link Long} in another.</dd>
+		 * <dt>Any Simple type like {@link String}, {@link Long}, ...</dt>
+		 * <dd>The result is mapped directly by the Couchbase Java driver and the {@link } in place. This works only for
+		 * results where all documents considered for the operation use the very same type for the field.</dd>
+		 * <dt>Any Domain type</dt>
+		 * <dd>Domain types can only be mapped if the if the result of the actual {@code distinct()} operation returns
+		 * {@link }.</dd>
+		 * <dt>{@link }</dt>
+		 * <dd>Using {@link } allows retrieval of the raw driver specific format, which returns eg. {@link }.</dd>
+		 * </dl>
+		 *
+		 * @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.
+	 *
+ 	 * @author Michael Reiche
+	 */
+	interface DistinctWithQuery<T> extends DistinctWithProjection {
+
+		/**
+		 * Set the filter {@link Query criteria} to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if criteria is {@literal null}.
+		 */
+		TerminatingDistinct<T> matching(Query query);
+	}
+
+	/**
+	 * Terminating distinct find operations.
+	 *
+ 	 * @author Michael Reiche
+	 */
+	interface TerminatingDistinct<T> extends DistinctWithQuery<T> {
+
+		/**
+		 * Get all matching distinct field values.
+		 *
+		 * @return empty {@link Flux} if not match found. Never {@literal null}.
+		 */
+		Flux<T> all();
+	}
+
+	interface ReactiveFindByQuery<T> extends FindByQueryConsistentWith<T>, FindInCollection<T>, FindDistinct {}
 
 }

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

@@ -15,16 +15,18 @@
  */
 package org.springframework.data.couchbase.core;
 
-import org.springframework.data.couchbase.core.support.TemplateUtils;
-import org.springframework.data.couchbase.core.query.Query;
-
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.data.couchbase.core.query.Query;
+import org.springframework.data.couchbase.core.support.TemplateUtils;
+
 import com.couchbase.client.java.query.QueryScanConsistency;
 import com.couchbase.client.java.query.ReactiveQueryResult;
 
 /**
+ * {@link ReactiveFindByQueryOperation} implementations for Couchbase.
+ *
  * @author Michael Nitschinger
  * @author Michael Reiche
  */
@@ -40,7 +42,8 @@ public ReactiveFindByQueryOperationSupport(final ReactiveCouchbaseTemplate templ
 
 	@Override
 	public <T> ReactiveFindByQuery<T> findByQuery(final Class<T> domainType) {
-		return new ReactiveFindByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED);
+		return new ReactiveFindByQuerySupport<>(template, domainType, ALL_QUERY, QueryScanConsistency.NOT_BOUNDED,
+				null);
 	}
 
 	static class ReactiveFindByQuerySupport<T> implements ReactiveFindByQuery<T> {
@@ -49,13 +52,15 @@ static class ReactiveFindByQuerySupport<T> implements ReactiveFindByQuery<T> {
 		private final Class<T> domainType;
 		private final Query query;
 		private final QueryScanConsistency scanConsistency;
+		private final String collection;
 
 		ReactiveFindByQuerySupport(final ReactiveCouchbaseTemplate template, final Class<T> domainType, final Query query,
-				final QueryScanConsistency scanConsistency) {
+				final QueryScanConsistency scanConsistency, final String collection) {
 			this.template = template;
 			this.domainType = domainType;
 			this.query = query;
 			this.scanConsistency = scanConsistency;
+			this.collection = collection;
 		}
 
 		@Override
@@ -66,12 +71,22 @@ public TerminatingFindByQuery<T> matching(Query query) {
 			} else {
 				scanCons = scanConsistency;
 			}
-			return new ReactiveFindByQuerySupport<>(template, domainType, query, scanCons);
+			return new ReactiveFindByQuerySupport<>(template, domainType, query, scanCons, collection);
 		}
 
 		@Override
 		public FindByQueryConsistentWith<T> consistentWith(QueryScanConsistency scanConsistency) {
-			return new ReactiveFindByQuerySupport<>(template, domainType, query, scanConsistency);
+			return new ReactiveFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		}
+
+		@Override
+		public FindInCollection<T> inCollection(String collection) {
+			return new ReactiveFindByQuerySupport<>(template, domainType, query, scanConsistency, collection);
+		}
+
+		@Override
+		public TerminatingDistinct<Object> distinct(String field) {
+			throw new RuntimeException(("not implemented"));
 		}
 
 		@Override
@@ -129,7 +144,6 @@ public Mono<Boolean> exists() {
 		private String assembleEntityQuery(final boolean count) {
 			return query.toN1qlSelectString(template, this.domainType, count);
 		}
-
 	}
 
 }

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

@@ -41,6 +41,12 @@ interface RemoveByQueryConsistentWith<T> extends RemoveByQueryWithQuery<T> {
 
 	}
 
-	interface ReactiveRemoveByQuery<T> extends RemoveByQueryConsistentWith<T> {}
+	interface RemoveByQueryInCollection<T> extends RemoveByQueryConsistentWith<T> {
+
+		RemoveByQueryConsistentWith<T> inCollection(String collection);
+
+	}
+
+	interface ReactiveRemoveByQuery<T> extends RemoveByQueryInCollection<T> {}
 
 }

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

@@ -91,6 +91,10 @@ public RemoveByQueryWithQuery<T> consistentWith(final QueryScanConsistency scanC
 			return new ReactiveRemoveByQuerySupport<>(template, domainType, query, scanConsistency);
 		}
 
+		@Override
+		public RemoveByQueryConsistentWith<T> inCollection(final String collection) {
+			return new ReactiveRemoveByQuerySupport<>(template, domainType, query, scanConsistency);
+		}
 		private String assembleDeleteQuery() {
 			return query.toN1qlRemoveString(template, this.domainType);
 		}