Polishing.

Add reactive ZRANGESTORE support. Support rangeAndStore in RedisZSet.

Refine assertion messages. Refine overloads.

Original pull request: #2370.
See #2345

Author: mp911de

src/main/asciidoc/appendix/appendix-command-reference.adoc

@@ -181,6 +181,7 @@
 |ZRANGEBYLEX |-
 |ZREVRANGEBYLEX |-
 |ZRANGEBYSCORE |X
+|ZRANGESTORE |X
 |ZRANK |X
 |ZREM |X
 |ZREMRANGEBYLEX |-

src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java

@@ -2711,6 +2711,12 @@ public Set<byte[]> zRevRangeByLex(byte[] key, org.springframework.data.domain.Ra
 		return convertAndReturn(delegate.zRevRangeByLex(key, range, limit), Converters.identityConverter());
 	}
 
+	@Override
+	public Set<String> zRevRangeByLex(String key, org.springframework.data.domain.Range<String> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return convertAndReturn(delegate.zRevRangeByLex(serialize(key), serialize(range), limit), byteSetToStringSet);
+	}
+
 	@Override
 	public Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey,
 								 org.springframework.data.domain.Range<byte[]> range,
@@ -2721,16 +2727,21 @@ public Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey,
 
 	@Override
 	public Long zRangeStoreByLex(String dstKey, String srcKey,
-							   org.springframework.data.domain.Range<String> range,
-							   org.springframework.data.redis.connection.Limit limit) {
+			org.springframework.data.domain.Range<String> range, org.springframework.data.redis.connection.Limit limit) {
 		return convertAndReturn(delegate.zRangeStoreByLex(serialize(dstKey), serialize(srcKey), serialize(range), limit),
 				Converters.identityConverter());
 	}
 
 	@Override
-	public Long zRangeStoreByScore(String dstKey, String srcKey, double min, double max,
-								   org.springframework.data.redis.connection.Limit limit) {
-		return convertAndReturn(delegate.zRangeStoreByScore(serialize(dstKey), serialize(srcKey), min, max, limit),
+	public Long zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return convertAndReturn(delegate.zRangeStoreRevByLex(dstKey, srcKey, range, limit), Converters.identityConverter());
+	}
+
+	@Override
+	public Long zRangeStoreRevByLex(String dstKey, String srcKey, org.springframework.data.domain.Range<String> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return convertAndReturn(delegate.zRangeStoreRevByLex(serialize(dstKey), serialize(srcKey), serialize(range), limit),
 				Converters.identityConverter());
 	}
 
@@ -2743,9 +2754,24 @@ public Long zRangeStoreByScore(byte[] dstKey, byte[] srcKey,
 	}
 
 	@Override
-	public Set<String> zRevRangeByLex(String key, org.springframework.data.domain.Range<String> range,
+	public Long zRangeStoreByScore(String dstKey, String srcKey, org.springframework.data.domain.Range<Number> range,
 			org.springframework.data.redis.connection.Limit limit) {
-		return convertAndReturn(delegate.zRevRangeByLex(serialize(key), serialize(range), limit), byteSetToStringSet);
+		return convertAndReturn(delegate.zRangeStoreByScore(serialize(dstKey), serialize(srcKey), range, limit),
+				Converters.identityConverter());
+	}
+
+	@Override
+	public Long zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<Number> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return convertAndReturn(delegate.zRangeStoreRevByScore(dstKey, srcKey, range, limit),
+				Converters.identityConverter());
+	}
+
+	@Override
+	public Long zRangeStoreRevByScore(String dstKey, String srcKey, org.springframework.data.domain.Range<Number> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return convertAndReturn(delegate.zRangeStoreRevByScore(serialize(dstKey), serialize(srcKey), range, limit),
+				Converters.identityConverter());
 	}
 
 	@Override

src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java

@@ -1846,6 +1846,14 @@ default Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey,
 		return zSetCommands().zRangeStoreByLex(dstKey, srcKey, range, limit);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */
+	@Override
+	@Deprecated
+	default Long zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<byte[]> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return zSetCommands().zRangeStoreRevByLex(dstKey, srcKey, range, limit);
+	}
+
 	/** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */
 	@Override
 	@Deprecated
@@ -1855,4 +1863,12 @@ default Long zRangeStoreByScore(byte[] dstKey, byte[] srcKey,
 		return zSetCommands().zRangeStoreByScore(dstKey, srcKey, range, limit);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */
+	@Override
+	@Deprecated
+	default Long zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range<Number> range,
+			org.springframework.data.redis.connection.Limit limit) {
+		return zSetCommands().zRangeStoreRevByScore(dstKey, srcKey, range, limit);
+	}
+
 }

src/main/java/org/springframework/data/redis/connection/Limit.java

@@ -52,6 +52,10 @@ public boolean isUnlimited() {
 		return this.equals(UNLIMITED);
 	}
 
+	public boolean isLimited() {
+		return !isUnlimited();
+	}
+
 	/**
 	 * @return new {@link Limit} indicating no limit;
 	 * @since 1.3

src/main/java/org/springframework/data/redis/connection/ReactiveZSetCommands.java

@@ -902,6 +902,250 @@ default Flux<Tuple> zRevRangeWithScores(ByteBuffer key, Range<Long> range) {
 	 */
 	Flux<CommandResponse<ZRangeCommand, Flux<Tuple>>> zRange(Publisher<ZRangeCommand> commands);
 
+	/**
+	 * {@code ZRANGESTORE} command parameters.
+	 *
+	 * @author Mark Paluch
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	class ZRangeStoreCommand extends KeyCommand {
+
+		private final ByteBuffer destKey;
+		private final RangeMode rangeMode;
+		private final Range<?> range;
+		private final Direction direction;
+		private final Limit limit;
+
+		private ZRangeStoreCommand(@Nullable ByteBuffer srcKey, @Nullable ByteBuffer destKey, RangeMode rangeMode,
+				Range<?> range, Direction direction, Limit limit) {
+
+			super(srcKey);
+			this.destKey = destKey;
+			this.rangeMode = rangeMode;
+			this.range = range;
+			this.direction = direction;
+			this.limit = limit;
+		}
+
+		/**
+		 * Creates a new {@link ZRangeStoreCommand} given a {@link Range} to obtain elements ordered from the lowest to the
+		 * highest score.
+		 *
+		 * @param range must not be {@literal null}.
+		 * @return a new {@link ZRangeCommand} for {@link Tuple}.
+		 */
+		public static ZRangeStoreCommand scoreWithin(Range<Double> range) {
+
+			Assert.notNull(range, "Range must not be null");
+
+			return new ZRangeStoreCommand(null, null, RangeMode.ByScore, range, Direction.ASC, Limit.unlimited());
+		}
+
+		/**
+		 * Creates a new {@link ZRangeStoreCommand} given a {@link Range} to obtain elements ordered from the highest to the
+		 * lowest score.
+		 *
+		 * @param range must not be {@literal null}.
+		 * @return a new {@link ZRangeStoreCommand} for {@link Tuple}.
+		 */
+		public static ZRangeStoreCommand reverseScoreWithin(Range<Double> range) {
+
+			Assert.notNull(range, "Range must not be null");
+
+			return new ZRangeStoreCommand(null, null, RangeMode.ByScore, range, Direction.DESC, Limit.unlimited());
+		}
+
+		/**
+		 * Creates a new {@link ZRangeStoreCommand} given a {@link Range} to obtain elements ordered from the lowest to the
+		 * highest lexicographical value.
+		 *
+		 * @param range must not be {@literal null}.
+		 * @return a new {@link ZRangeCommand} for {@link Tuple}.
+		 */
+		public static ZRangeStoreCommand valueWithin(Range<String> range) {
+
+			Assert.notNull(range, "Range must not be null");
+
+			return new ZRangeStoreCommand(null, null, RangeMode.ByLex, range, Direction.ASC, Limit.unlimited());
+		}
+
+		/**
+		 * Creates a new {@link ZRangeStoreCommand} given a {@link Range} to obtain elements ordered from the highest to the
+		 * lowest lexicographical value.
+		 *
+		 * @param range must not be {@literal null}.
+		 * @return a new {@link ZRangeStoreCommand} for {@link Tuple}.
+		 */
+		public static ZRangeStoreCommand reverseValueWithin(Range<String> range) {
+
+			Assert.notNull(range, "Range must not be null");
+
+			return new ZRangeStoreCommand(null, null, RangeMode.ByLex, range, Direction.DESC, Limit.unlimited());
+		}
+
+		/**
+		 * Applies the {@literal key}. Constructs a new command instance with all previously configured properties.
+		 *
+		 * @param key must not be {@literal null}.
+		 * @return a new {@link ZRangeStoreCommand} with {@literal key} applied.
+		 */
+		public ZRangeStoreCommand from(ByteBuffer key) {
+
+			Assert.notNull(key, "Key must not be null");
+
+			return new ZRangeStoreCommand(key, destKey, rangeMode, range, direction, limit);
+		}
+
+		/**
+		 * Applies the {@literal key}. Constructs a new command instance with all previously configured properties.
+		 *
+		 * @param key must not be {@literal null}.
+		 * @return a new {@link ZRangeStoreCommand} with {@literal key} applied.
+		 */
+		public ZRangeStoreCommand to(ByteBuffer key) {
+
+			Assert.notNull(key, "Key must not be null");
+
+			return new ZRangeStoreCommand(getKey(), key, rangeMode, range, direction, limit);
+		}
+
+		/**
+		 * Applies the {@literal limit}. Constructs a new command instance with all previously configured properties.
+		 *
+		 * @param limit must not be {@literal null}.
+		 * @return a new {@link ZRangeStoreCommand} with {@literal key} applied.
+		 */
+		public ZRangeStoreCommand limit(Limit limit) {
+
+			Assert.notNull(limit, "Limit must not be null");
+
+			return new ZRangeStoreCommand(getKey(), getDestKey(), rangeMode, range, direction, limit);
+		}
+
+		public ByteBuffer getDestKey() {
+			return destKey;
+		}
+
+		public RangeMode getRangeMode() {
+			return rangeMode;
+		}
+
+		public Range<?> getRange() {
+			return range;
+		}
+
+		public Direction getDirection() {
+			return direction;
+		}
+
+		public Limit getLimit() {
+			return limit;
+		}
+
+		public enum RangeMode {
+			ByScore, ByLex,
+		}
+	}
+
+	/**
+	 * Add elements from {@code srcKey} by score {@literal range} to {@code destKey}.
+	 *
+	 * @param srcKey must not be {@literal null}.
+	 * @param destKey must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit must not be {@literal null}.
+	 * @return
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	default Mono<Long> zRangeStoreByScore(ByteBuffer srcKey, ByteBuffer destKey, Range<Double> range, Limit limit) {
+
+		Assert.notNull(srcKey, "Source key must not be null");
+		Assert.notNull(destKey, "Destination key must not be null");
+		Assert.notNull(range, "Range must not be null");
+		Assert.notNull(limit, "Limit must not be null");
+
+		return zRangeStore(Mono.just(ZRangeStoreCommand.scoreWithin(range).from(srcKey).to(destKey).limit(limit))) //
+				.flatMap(CommandResponse::getOutput).next();
+	}
+
+	/**
+	 * Add elements from {@code srcKey} by lexicographical {@literal range} to {@code destKey}.
+	 *
+	 * @param srcKey must not be {@literal null}.
+	 * @param destKey must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit must not be {@literal null}.
+	 * @return
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	default Mono<Long> zRangeStoreByLex(ByteBuffer srcKey, ByteBuffer destKey, Range<String> range, Limit limit) {
+
+		Assert.notNull(srcKey, "Source key must not be null");
+		Assert.notNull(destKey, "Destination key must not be null");
+		Assert.notNull(range, "Range must not be null");
+		Assert.notNull(limit, "Limit must not be null");
+
+		return zRangeStore(Mono.just(ZRangeStoreCommand.valueWithin(range).from(srcKey).to(destKey).limit(limit))) //
+				.flatMap(CommandResponse::getOutput).next();
+	}
+
+	/**
+	 * Add elements from {@code srcKey} by reverse score {@literal range} to {@code destKey}.
+	 *
+	 * @param srcKey must not be {@literal null}.
+	 * @param destKey must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit must not be {@literal null}.
+	 * @return
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	default Mono<Long> zRangeStoreRevByScore(ByteBuffer srcKey, ByteBuffer destKey, Range<Double> range, Limit limit) {
+
+		Assert.notNull(srcKey, "Source key must not be null");
+		Assert.notNull(destKey, "Destination key must not be null");
+		Assert.notNull(range, "Range must not be null");
+		Assert.notNull(limit, "Limit must not be null");
+
+		return zRangeStore(Mono.just(ZRangeStoreCommand.reverseScoreWithin(range).from(srcKey).to(destKey).limit(limit))) //
+				.flatMap(CommandResponse::getOutput).next();
+	}
+
+	/**
+	 * Add elements from {@code srcKey} by reverse lexicographical {@literal range} to {@code destKey}.
+	 *
+	 * @param srcKey must not be {@literal null}.
+	 * @param destKey must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit must not be {@literal null}.
+	 * @return
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	default Mono<Long> zRangeStoreRevByLex(ByteBuffer srcKey, ByteBuffer destKey, Range<String> range, Limit limit) {
+
+		Assert.notNull(srcKey, "Source key must not be null");
+		Assert.notNull(destKey, "Destination key must not be null");
+		Assert.notNull(range, "Range must not be null");
+		Assert.notNull(limit, "Limit must not be null");
+
+		return zRangeStore(Mono.just(ZRangeStoreCommand.reverseValueWithin(range).from(srcKey).to(destKey).limit(limit))) //
+				.flatMap(CommandResponse::getOutput).next();
+	}
+
+	/**
+	 * Get set of {@link Tuple}s in {@literal range} from sorted set.
+	 *
+	 * @param commands must not be {@literal null}.
+	 * @return
+	 * @since 3.0
+	 * @see <a href="https://redis.io/commands/zrangestore">Redis Documentation: ZRANGESTORE</a>
+	 */
+	Flux<CommandResponse<ZRangeStoreCommand, Mono<Long>>> zRangeStore(Publisher<ZRangeStoreCommand> commands);
+
 	/**
 	 * {@literal ZRANGEBYSCORE}/{@literal ZREVRANGEBYSCORE}.
 	 *