Add RangeScan support.

Closes #1599.

Author: mikereiche

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

@@ -22,16 +22,11 @@
 import org.springframework.data.couchbase.core.support.InScope;
 import org.springframework.data.couchbase.core.support.WithBatchByteLimit;
 import org.springframework.data.couchbase.core.support.WithBatchItemLimit;
-import org.springframework.data.couchbase.core.support.IdsOnly;
-import org.springframework.data.couchbase.core.support.WithLimit;
-import org.springframework.data.couchbase.core.support.WithSampling;
 import org.springframework.data.couchbase.core.support.WithScanOptions;
 import org.springframework.data.couchbase.core.support.WithScanSort;
 
 import com.couchbase.client.java.kv.MutationState;
 import com.couchbase.client.java.kv.ScanOptions;
-import com.couchbase.client.java.kv.ScanSort;
-import org.springframework.data.couchbase.core.support.WithSeed;
 
 /**
  * Get Operations
@@ -68,10 +63,27 @@ interface TerminatingRangeScan<T> /*extends OneAndAllId<T>*/ {
 		 *
 		 * @param upper
 		 * @param lower
-		 * @return the list of found entities.
+		 * @return the list of found keys.
 		 */
 		Stream<String> rangeScanIds(String lower, String upper);
 
+		/**
+		 * Range Scan
+		 *
+		 * @param limit
+		 * @param seed
+		 * @return the list of found entities.
+		 */
+		Stream<T> samplingScan(Long limit, Long... seed);
+
+		/**
+		 * Range Scan Ids
+		 *
+		 * @param limit
+		 * @param seed
+		 * @return the list of keys
+		 */
+		Stream<String> samplingScanIds(Long limit, Long... seed);
 	}
 
 	/**
@@ -119,24 +131,16 @@ interface RangeScanInScope<T> extends RangeScanInCollection<T>, InScope<T> {
 		RangeScanInCollection<T> inScope(String scope);
 	}
 
-	interface RangeScanWithSampling<T> extends RangeScanInScope<T>, WithSampling<T> {
-		/**
-		 * sampling
-		 *
-		 * @param isSampling
-		 */
-		@Override
-		RangeScanInScope<T> withSampling(Boolean isSampling);
-	}
 
-	interface RangeScanWithSort<T> extends RangeScanWithSampling<T>, WithScanSort<T> {
+
+	interface RangeScanWithSort<T> extends RangeScanInScope<T>, WithScanSort<T> {
 		/**
 		 * sort
 		 *
 		 * @param sort
 		 */
 		@Override
-		RangeScanWithSampling<T> withSort(ScanSort sort);
+		RangeScanInScope<T> withSort(Object sort);
 	}
 
 	/**
@@ -173,46 +177,7 @@ interface RangeScanWithProjection<T> extends RangeScanConsistentWith<T> {
 		<R> RangeScanConsistentWith<R> as(Class<R> returnType);
 	}
 
-	interface RangeScanIdsOnly<T> extends RangeScanWithProjection<T>, IdsOnly<T> {
-
-		/**
-		 * determines if result are just ids or ids plus contents
-		 *
-		 * @param idsOnly must not be {@literal null}.
-		 * @return new instance of {@link RangeScanWithProjection}.
-		 * @throws IllegalArgumentException if returnType is {@literal null}.
-		 */
-		@Override
-		RangeScanWithProjection<T> idsOnly(Boolean idsOnly);
-	}
-
-	interface RangeScanWithLimit<T> extends RangeScanIdsOnly<T>, WithLimit<T> {
-
-		/**
-		 * determines if result are just ids or ids plus contents
-		 *
-		 * @param limit must not be {@literal null}.
-		 * @return new instance of {@link RangeScanWithProjection}.
-		 * @throws IllegalArgumentException if returnType is {@literal null}.
-		 */
-		@Override
-		RangeScanIdsOnly<T> withLimit(Long limit);
-	}
-
-	interface RangeScanWithSeed<T> extends RangeScanWithLimit<T>, WithSeed<T> {
-
-		/**
-		 * determines if result are just ids or ids plus contents
-		 *
-		 * @param seed must not be {@literal null}.
-		 * @return new instance of {@link RangeScanWithProjection}.
-		 * @throws IllegalArgumentException if returnType is {@literal null}.
-		 */
-		@Override
-		RangeScanWithLimit<T> withSeed(Long seed);
-	}
-
-	interface RangeScanWithBatchItemLimit<T> extends RangeScanWithSeed<T>, WithBatchItemLimit<T> {
+	interface RangeScanWithBatchItemLimit<T> extends RangeScanWithProjection<T>, WithBatchItemLimit<T> {
 
 		/**
 		 * determines if result are just ids or ids plus contents
@@ -222,7 +187,7 @@ interface RangeScanWithBatchItemLimit<T> extends RangeScanWithSeed<T>, WithBatch
 		 * @throws IllegalArgumentException if returnType is {@literal null}.
 		 */
 		@Override
-		RangeScanWithSeed<T> withBatchItemLimit(Integer batchByteLimit);
+		RangeScanWithProjection<T> withBatchItemLimit(Integer batchByteLimit);
 	}
 
 	interface RangeScanWithBatchByteLimit<T> extends RangeScanWithBatchItemLimit<T>, WithBatchByteLimit<T> {
@@ -235,7 +200,7 @@ interface RangeScanWithBatchByteLimit<T> extends RangeScanWithBatchItemLimit<T>,
 		 * @throws IllegalArgumentException if returnType is {@literal null}.
 		 */
 		@Override
-		RangeScanWithBatchByteLimit<T> withBatchByteLimit(Integer batchByteLimit);
+		RangeScanWithBatchItemLimit<T> withBatchByteLimit(Integer batchByteLimit);
 	}
 
 	/**

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

@@ -23,7 +23,6 @@
 
 import com.couchbase.client.java.kv.MutationState;
 import com.couchbase.client.java.kv.ScanOptions;
-import com.couchbase.client.java.kv.ScanSort;
 
 public class ExecutableRangeScanOperationSupport implements ExecutableRangeScanOperation {
 
@@ -36,7 +35,7 @@ public class ExecutableRangeScanOperationSupport implements ExecutableRangeScanO
 	@Override
 	public <T> ExecutableRangeScan<T> rangeScan(Class<T> domainType) {
 		return new ExecutableRangeScanSupport<>(template, domainType, OptionsBuilder.getScopeFrom(domainType),
-				OptionsBuilder.getCollectionFrom(domainType), null, null, null, null, null, null, null, null, null);
+        OptionsBuilder.getCollectionFrom(domainType), null, null, null, false, null, null);
 	}
 
 	static class ExecutableRangeScanSupport<T> implements ExecutableRangeScan<T> {
@@ -46,121 +45,101 @@ static class ExecutableRangeScanSupport<T> implements ExecutableRangeScan<T> {
 		private final String scope;
 		private final String collection;
 		private final ScanOptions options;
-		private final Boolean isSamplingScan;
-		private final ScanSort sort;
+		private final Object sort;
 		private final MutationState mutationState;
-		private final Boolean withContent;
-		private final Long limit;
-		private final Long seed;
+    private final Boolean idsOnly;
 		private final Integer batchItemLimit;
 		private final Integer batchByteLimit;
 		private final ReactiveRangeScanSupport<T> reactiveSupport;
 
 		ExecutableRangeScanSupport(CouchbaseTemplate template, Class<T> domainType, String scope, String collection,
-				ScanOptions options, Boolean isSamplingScan, ScanSort sort, MutationState mutationState, Boolean withContent,
-				Long seed, Long limit, Integer batchItemLimit, Integer batchByteLimit) {
+															 ScanOptions options, Object sort, MutationState mutationState, Boolean idsOnly,
+															 Integer batchItemLimit, Integer batchByteLimit) {
 			this.template = template;
 			this.domainType = domainType;
 			this.scope = scope;
 			this.collection = collection;
 			this.options = options;
-			this.isSamplingScan = isSamplingScan;
 			this.sort = sort;
 			this.mutationState = mutationState;
-			this.withContent = withContent;
-			this.limit = limit;
-			this.seed = seed;
+      this.idsOnly = idsOnly;
 			this.batchItemLimit = batchItemLimit;
 			this.batchByteLimit = batchByteLimit;
 			this.reactiveSupport = new ReactiveRangeScanSupport<>(template.reactive(), domainType, scope, collection, options,
-					isSamplingScan, sort, mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit,
+				sort, mutationState, batchItemLimit, batchByteLimit,
 					new NonReactiveSupportWrapper(template.support()));
 		}
 
 		@Override
 		public TerminatingRangeScan<T> withOptions(final ScanOptions options) {
 			Assert.notNull(options, "Options must not be null.");
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
 		public RangeScanWithOptions<T> inCollection(final String collection) {
 			return new ExecutableRangeScanSupport<>(template, domainType, scope,
-					collection != null ? collection : this.collection, options, isSamplingScan, sort, mutationState, withContent,
-					limit, seed, batchItemLimit, batchByteLimit);
+          collection != null ? collection : this.collection, options, sort, mutationState, idsOnly,
+				batchItemLimit, batchByteLimit);
 		}
 
 		@Override
 		public RangeScanInCollection<T> inScope(final String scope) {
 			return new ExecutableRangeScanSupport<>(template, domainType, scope != null ? scope : this.scope, collection,
-					options, isSamplingScan, sort, mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+          options, sort, mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
-		public RangeScanInScope<T> withSampling(Boolean isSamplingScan) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
-		}
-
-		@Override
-		public RangeScanWithSampling<T> withSort(ScanSort sort) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+    public RangeScanInScope<T> withSort(Object sort) {
+			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
 		public RangeScanWithSort<T> consistentWith(MutationState mutationState) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
 		public <R> RangeScanConsistentWith<R> as(Class<R> returnType) {
-			return new ExecutableRangeScanSupport<>(template, returnType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
-		}
-
-		@Override
-		public RangeScanWithProjection<T> idsOnly(Boolean withContent) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
-		}
-
-		@Override
-		public RangeScanIdsOnly<T> withLimit(Long limit) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-				mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+			return new ExecutableRangeScanSupport<>(template, returnType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
-		public RangeScanWithLimit<T> withSeed(Long seed) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-				mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+    public RangeScanWithProjection<T> withBatchItemLimit(Integer batchItemLimit) {
+			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
-		public RangeScanWithSeed<T> withBatchItemLimit(Integer batchItemLimit) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
-		}
-
-		@Override
-		public RangeScanWithBatchByteLimit<T> withBatchByteLimit(Integer batchByteLimit) {
-			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, isSamplingScan, sort,
-					mutationState, withContent, limit, seed, batchItemLimit, batchByteLimit);
+		public RangeScanWithBatchItemLimit<T> withBatchByteLimit(Integer batchByteLimit) {
+			return new ExecutableRangeScanSupport<>(template, domainType, scope, collection, options, sort,
+          mutationState, idsOnly, batchItemLimit, batchByteLimit);
 		}
 
 		@Override
 		public Stream<T> rangeScan(String lower, String upper) {
-			return reactiveSupport.rangeScan(lower, upper).toStream();
+      return reactiveSupport.rangeScan(lower, upper, false, null, null).toStream();
 		}
 
 		@Override
 		public Stream<String> rangeScanIds(String lower, String upper) {
-			return reactiveSupport.rangeScanIds(lower, upper).toStream();
+      return reactiveSupport.rangeScanIds(lower, upper, false, null, null).toStream();
 		}
 
+    @Override
+    public Stream<T> samplingScan(Long limit, Long... seed) {
+      return reactiveSupport.sampleScan(limit, seed).toStream();
+    }
+
+    @Override
+    public Stream<String> samplingScanIds(Long limit, Long... seed) {
+      return reactiveSupport.sampleScanIds(limit, seed).toStream();
+    }
+
 	}
 
 }

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

@@ -22,5 +22,5 @@
 public interface FluentCouchbaseOperations extends ExecutableUpsertByIdOperation, ExecutableInsertByIdOperation,
 		ExecutableReplaceByIdOperation, ExecutableFindByIdOperation, ExecutableFindFromReplicasByIdOperation,
 		ExecutableFindByQueryOperation, ExecutableFindByAnalyticsOperation, ExecutableExistsByIdOperation,
-		ExecutableRemoveByIdOperation, ExecutableRemoveByQueryOperation, ExecutableRangeScanOperation,
+		ExecutableRemoveByIdOperation, ExecutableRemoveByQueryOperation, ExecutableMutateInByIdOperation,
         ExecutableRangeScanOperation  {}

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

@@ -22,5 +22,5 @@
 public interface ReactiveFluentCouchbaseOperations extends ReactiveUpsertByIdOperation, ReactiveInsertByIdOperation,
 		ReactiveReplaceByIdOperation, ReactiveFindByIdOperation, ReactiveExistsByIdOperation,
 		ReactiveFindByAnalyticsOperation, ReactiveFindFromReplicasByIdOperation, ReactiveFindByQueryOperation,
-		ReactiveRemoveByIdOperation, ReactiveRemoveByQueryOperation, ReactiveRangeScanOperation,
+		ReactiveRemoveByIdOperation, ReactiveRemoveByQueryOperation, ReactiveMutateInByIdOperation,
         ReactiveRangeScanOperation {}