DATAREDIS-729 - Add support for ZLEXCOUNT.

Original pull request: #569.

Author: anshlykov

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

@@ -1659,6 +1659,24 @@ public Long zUnionStore(byte[] destKey, byte[]... sets) {
 		return convertAndReturn(delegate.zUnionStore(destKey, sets), identityConverter);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisZSetCommands#zLexCount(byte[], org.springframework.data.redis.connection.RedisZSetCommands.Range)
+	 */
+	@Override
+	public Long zLexCount(byte[] key, Range range) {
+		return delegate.zLexCount(key, range);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#zLexCount(java.lang.String, org.springframework.data.redis.connection.RedisZSetCommands.Range)
+	 */
+	@Override
+	public Long zLexCount(String key, Range range) {
+		return delegate.zLexCount(serialize(key), range);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.RedisKeyCommands#pExpire(byte[], long)

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

@@ -55,6 +55,7 @@
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Tugdual Grall
+ * @author Andrey Shlykov
  * @since 2.0
  */
 public interface DefaultedRedisConnection extends RedisConnection {
@@ -1093,6 +1094,13 @@ default Set<byte[]> zRangeByScore(byte[] key, String min, String max, long offse
 		return zSetCommands().zRangeByScore(key, min, max, offset, count);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */
+	@Override
+	@Deprecated
+	default Long zLexCount(byte[] key, Range range) {
+		return zSetCommands().zLexCount(key, range);
+	}
+
 	// HASH COMMANDS
 
 	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */

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

@@ -46,6 +46,7 @@
  *
  * @author Christoph Strobl
  * @author Mark Paluch
+ * @author Andrey Shlykov
  * @since 2.0
  */
 public interface ReactiveZSetCommands {
@@ -1935,4 +1936,79 @@ default Flux<ByteBuffer> zRevRangeByLex(ByteBuffer key, Range<String> range, Lim
 	 * @see <a href="https://redis.io/commands/zrevrangebylex">Redis Documentation: ZREVRANGEBYLEX</a>
 	 */
 	Flux<CommandResponse<ZRangeByLexCommand, Flux<ByteBuffer>>> zRangeByLex(Publisher<ZRangeByLexCommand> commands);
+
+	/**
+	 * {@code ZLEXCOUNT} command parameters.
+	 *
+	 * @author Andrey Shlykov
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 */
+	class ZLexCountCommand extends KeyCommand {
+
+		private final Range<String> range;
+
+		private ZLexCountCommand(@Nullable ByteBuffer key, Range<String> range) {
+			super(key);
+			this.range = range;
+		}
+
+		/**
+		 * Creates a new {@link ZLexCountCommand} given a {@link Range} of {@link String} to retrieve elements
+		 * count.
+		 *
+		 * @param range must not be {@literal null}.
+		 * @return a new {@link ZLexCountCommand} for {@link Range}.
+		 */
+		public static ZLexCountCommand stringsWithin(Range<String> range) {
+
+			Assert.notNull(range, "Range must not be null!");
+
+			return new ZLexCountCommand(null, range);
+		}
+
+		/**
+		 * 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 ZLexCountCommand} with {@literal key} applied.
+		 */
+		public ZLexCountCommand forKey(ByteBuffer key) {
+
+			Assert.notNull(key, "Key must not be null!");
+
+			return new ZLexCountCommand(key, range);
+		}
+
+		/**
+		 * @return
+		 */
+		public Range<String> getRange() {
+			return range;
+		}
+	}
+
+	/**
+	 * Count number of elements within sorted set with value within {@link Range}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @return
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 */
+	default Mono<Long> zLexCount(ByteBuffer key, Range<String> range) {
+		return zLexCount(Mono.just(ZLexCountCommand.stringsWithin(range).forKey(key))).next()
+				.map(NumericResponse::getOutput);
+	}
+
+	/**
+	 * Count number of elements within sorted set with value within {@link Range}.
+	 *
+	 * @param commands must not be {@literal null}.
+	 * @return
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 */
+	Flux<NumericResponse<ZLexCountCommand, Long>> zLexCount(Publisher<ZLexCountCommand> commands);
+
 }

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

@@ -1059,4 +1059,16 @@ default Set<byte[]> zRevRangeByLex(byte[] key, Range range) {
 	@Nullable
 	Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit);
 
+	/**
+	 * Count number of elements within sorted set with value between {@code Range#min} and {@code Range#max}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 */
+	@Nullable
+	Long zLexCount(byte[] key, Range range);
+
 }

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

@@ -1541,6 +1541,19 @@ default Set<String> zRevRangeByLex(String key, Range range) {
 	 */
 	Set<String> zRevRangeByLex(String key, Range range, Limit limit);
 
+	/**
+	 * Count number of elements within sorted set with value between {@code Range#min} and {@code Range#max}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 * @see RedisZSetCommands#zLexCount(byte[], Range)
+	 */
+	@Nullable
+	Long zLexCount(String key, Range range);
+
 	// -------------------------------------------------------------------------
 	// Methods dealing with Redis Hashes
 	// -------------------------------------------------------------------------

src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java

@@ -795,6 +795,26 @@ public Set<byte[]> zRangeByScore(byte[] key, String min, String max, long offset
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisZSetCommands#zLexCount(byte[], org.springframework.data.redis.connection.RedisZSetCommands.Range)
+	 */
+	@Override
+	public Long zLexCount(byte[] key, Range range) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(range, "Range must not be null!");
+
+		byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES);
+		byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES);
+
+		try {
+			return connection.getCluster().zlexcount(key, min, max);
+		} catch (Exception ex) {
+			throw convertJedisAccessException(ex);
+		}
+	}
+
 	private DataAccessException convertJedisAccessException(Exception ex) {
 		return connection.convertJedisAccessException(ex);
 	}

src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java

@@ -942,6 +942,34 @@ public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisZSetCommands#zLexCount(byte[], org.springframework.data.redis.connection.RedisZSetCommands.Range)
+	 */
+	@Override
+	public Long zLexCount(byte[] key, Range range) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(range, "Range must not be null!");
+
+		byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES);
+		byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES);
+
+		try {
+			if (isPipelined()) {
+				pipeline(connection.newJedisResult(connection.getRequiredPipeline().zlexcount(key, min, max)));
+				return null;
+			}
+			if (isQueueing()) {
+				transaction(connection.newJedisResult(connection.getRequiredTransaction().zlexcount(key, min, max)));
+				return null;
+			}
+			return connection.getJedis().zlexcount(key, min, max);
+		} catch (Exception ex) {
+			throw convertJedisAccessException(ex);
+		}
+	}
+
 	private boolean isPipelined() {
 		return connection.isPipelined();
 	}

src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommands.java

@@ -45,6 +45,7 @@
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Michele Mancioppi
+ * @author Andrey Shlykov
  * @since 2.0
  */
 class LettuceReactiveZSetCommands implements ReactiveZSetCommands {
@@ -484,6 +485,24 @@ public Flux<CommandResponse<ZRangeByLexCommand, Flux<ByteBuffer>>> zRangeByLex(
 		}));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.ReactiveZSetCommands#zLexCount(org.reactivestreams.Publisher)
+	 */
+	@Override
+	public Flux<NumericResponse<ZLexCountCommand, Long>> zLexCount(Publisher<ZLexCountCommand> commands) {
+
+		return connection.execute(cmd -> Flux.from(commands).concatMap(command -> {
+
+			Assert.notNull(command.getKey(), "Key must not be null!");
+			Assert.notNull(command.getRange(), "Range must not be null!");
+
+			Mono<Long> result = cmd.zlexcount(command.getKey(), RangeConverter.toRange(command.getRange()));
+
+			return result.map(value -> new NumericResponse<>(command, value));
+		}));
+	}
+
 	private static ZStoreArgs zStoreArgs(@Nullable Aggregate aggregate, @Nullable List<Double> weights) {
 
 		ZStoreArgs args = new ZStoreArgs();

src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java

@@ -927,6 +927,31 @@ public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisZSetCommands#zLexCount(byte[], org.springframework.data.redis.connection.RedisZSetCommands.Range)
+	 */
+	@Override
+	public Long zLexCount(byte[] key, Range range) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(range, "Range must not be null!");
+
+		try {
+			if (isPipelined()) {
+				pipeline(connection.newLettuceResult(getAsyncConnection().zlexcount(key, LettuceConverters.toRange(range))));
+				return null;
+			}
+			if (isQueueing()) {
+				transaction(connection.newLettuceResult(getAsyncConnection().zlexcount(key, LettuceConverters.toRange(range))));
+				return null;
+			}
+			return getConnection().zlexcount(key, LettuceConverters.toRange(range, true));
+		} catch (Exception ex) {
+			throw convertLettuceAccessException(ex);
+		}
+	}
+
 	private boolean isPipelined() {
 		return connection.isPipelined();
 	}

src/main/java/org/springframework/data/redis/core/BoundZSetOperations.java

@@ -33,6 +33,7 @@
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Wongoo (望哥)
+ * @author Andrey Shlykov
  */
 public interface BoundZSetOperations<K, V> extends BoundKeyOperations<K> {
 
@@ -414,6 +415,17 @@ default Set<V> reverseRangeByLex(Range range) {
 	@Nullable
 	Set<V> reverseRangeByLex(Range range, Limit limit);
 
+	/**
+	 * Count number of elements within sorted set with value between {@code Range#min} and {@code Range#max}.
+	 *
+	 * @param range must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @since 2.4
+	 * @see <a href="https://redis.io/commands/zlexcount">Redis Documentation: ZLEXCOUNT</a>
+	 */
+	@Nullable
+	Long lexCount(Range range);
+
 	/**
 	 * @return never {@literal null}.
 	 */