Add Range and Limit support to ZSetOperations.rangeByScoreWithScores

This commit adds support for the Range and Limit parameters to the
rangeByScoreWithScores and reverseRangeByScoreWithScores methods
in ZSetOperations interface.

The implementation follows the same pattern already used for other
methods like rangeByLex, providing a more flexible and consistent API
for working with Redis sorted sets.

New methods:
- rangeByScoreWithScores(K key, Range<Double> range)
- rangeByScoreWithScores(K key, Range<Double> range, Limit limit)
- reverseRangeByScoreWithScores(K key, Range<Double> range)
- reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit)

Unit and integration tests added to verify functionality.

Fixes #3139
Related to #796 and #938

Signed-off-by: kssumin <[email protected]>

Author: kssumin

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

@@ -43,6 +43,7 @@
  * @author Andrey Shlykov
  * @author Shyngys Sapraliyev
  * @author John Blum
+ * @author Kim Sumin
  */
 class DefaultZSetOperations<K, V> extends AbstractOperations<K, V> implements ZSetOperations<K, V> {
 
@@ -638,6 +639,48 @@ public Cursor<TypedTuple<V>> scan(K key, ScanOptions options) {
 		return new ConvertingCursor<>(cursor, this::deserializeTuple);
 	}
 
+	@Override
+	public Set<TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, Limit limit) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(range, "Range must not be null!");
+
+		byte[] rawKey = rawKey(key);
+
+		return execute(connection -> {
+			Set<Tuple> result;
+
+			if (limit.isUnlimited()) {
+				result = connection.zRangeByScoreWithScores(rawKey, range);
+			} else {
+				result = connection.zRangeByScoreWithScores(rawKey, range, limit);
+			}
+
+			return deserializeTupleValues(result);
+		});
+	}
+
+	@Override
+	public Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit) {
+
+		Assert.notNull(key, "Key must not be null!");
+		Assert.notNull(range, "Range must not be null!");
+
+		byte[] rawKey = rawKey(key);
+
+		return execute(connection -> {
+			Set<Tuple> result;
+
+			if (limit.isUnlimited()) {
+				result = connection.zRevRangeByScoreWithScores(rawKey, range);
+			} else {
+				result = connection.zRevRangeByScoreWithScores(rawKey, range, limit);
+			}
+
+			return deserializeTupleValues(result);
+		});
+	}
+
 	public Set<byte[]> rangeByScore(K key, String min, String max) {
 
 		byte[] rawKey = rawKey(key);

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

@@ -40,6 +40,7 @@
  * @author Wongoo (望哥)
  * @author Andrey Shlykov
  * @author Shyngys Sapraliyev
+ * @author Kim Sumin
  */
 public interface ZSetOperations<K, V> {
 
@@ -1271,4 +1272,63 @@ default Long reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<? extends Num
 	 * @return never {@literal null}.
 	 */
 	RedisOperations<K, V> getOperations();
+
+
+	/**
+	 * Get set of {@link TypedTuple}s where score is between the values defined by the
+	 * {@link Range} from sorted set.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/zrangebyscore">Redis Documentation: ZRANGEBYSCORE</a>
+	 * @since 3.5 (or next version number)
+	 */
+	@Nullable
+	default Set<TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range) {
+		return rangeByScoreWithScores(key, range, Limit.unlimited());
+	}
+
+	/**
+	 * Get set of {@link TypedTuple}s where score is between the values defined by the
+	 * {@link Range} and limited by the {@link Limit} from sorted set.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit can be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/zrangebyscore">Redis Documentation: ZRANGEBYSCORE</a>
+	 * @since 3.5 (or next version number)
+	 */
+	@Nullable
+	Set<TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, Limit limit);
+
+	/**
+	 * Get set of {@link TypedTuple}s where score is between the values defined by the
+	 * {@link Range} from sorted set ordered from high to low.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/zrevrangebyscore">Redis Documentation: ZREVRANGEBYSCORE</a>
+	 * @since 3.5 (or next version number)
+	 */
+	@Nullable
+	default Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range) {
+		return reverseRangeByScoreWithScores(key, range, Limit.unlimited());
+	}
+
+	/**
+	 * Get set of {@link TypedTuple}s where score is between the values defined by the
+	 * {@link Range} and limited by the {@link Limit} from sorted set ordered from high to low.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param range must not be {@literal null}.
+	 * @param limit can be {@literal null}.
+	 * @return {@literal null} when used in pipeline / transaction.
+	 * @see <a href="https://redis.io/commands/zrevrangebyscore">Redis Documentation: ZREVRANGEBYSCORE</a>
+	 * @since 3.5 (or next version number)
+	 */
+	@Nullable
+	Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit);
 }

src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsIntegrationTests.java

@@ -21,6 +21,7 @@
 
 import java.io.IOException;
 import java.time.Duration;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
@@ -53,6 +54,7 @@
  * @author Mark Paluch
  * @author Wongoo (望哥)
  * @author Andrey Shlykov
+ * @author Kim Sumin
  * @param <K> Key type
  * @param <V> Value type
  */
@@ -661,4 +663,100 @@ void testZsetUnionWithAggregateWeights() {
 		assertThat(zSetOps.score(key1, value1)).isCloseTo(6.0, offset(0.1));
 	}
 
+	@ParameterizedRedisTest // GH-3139
+	void testRangeByScoreWithScoresWithRange() {
+
+		K key = keyFactory.instance();
+		V value1 = valueFactory.instance();
+		V value2 = valueFactory.instance();
+		V value3 = valueFactory.instance();
+
+		zSetOps.add(key, value1, 1.9);
+		zSetOps.add(key, value2, 3.7);
+		zSetOps.add(key, value3, 5.8);
+
+		Range<Double> range = Range.of(Range.Bound.inclusive(1.5), Range.Bound.exclusive(5.0));
+
+		Set<TypedTuple<V>> results = zSetOps.rangeByScoreWithScores(key, range);
+
+		assertThat(results).hasSize(2)
+				.contains(new DefaultTypedTuple<>(value1, 1.9))
+				.contains(new DefaultTypedTuple<>(value2, 3.7));
+	}
+
+	@ParameterizedRedisTest // GH-3139
+	void testRangeByScoreWithScoresWithRangeAndLimit() {
+
+		K key = keyFactory.instance();
+		V value1 = valueFactory.instance();
+		V value2 = valueFactory.instance();
+		V value3 = valueFactory.instance();
+		V value4 = valueFactory.instance();
+
+		zSetOps.add(key, value1, 1.0);
+		zSetOps.add(key, value2, 2.0);
+		zSetOps.add(key, value3, 3.0);
+		zSetOps.add(key, value4, 4.0);
+
+		Range<Double> range = Range.of(Range.Bound.unbounded(), Range.Bound.inclusive(4.0));
+		Limit limit = Limit.limit().offset(1).count(2);
+
+		Set<TypedTuple<V>> results = zSetOps.rangeByScoreWithScores(key, range, limit);
+
+		assertThat(results).hasSize(2)
+				.contains(new DefaultTypedTuple<>(value2, 2.0))
+				.contains(new DefaultTypedTuple<>(value3, 3.0));
+	}
+
+	@ParameterizedRedisTest // GH-3139
+	void testReverseRangeByScoreWithScoresWithRange() {
+
+		K key = keyFactory.instance();
+		V value1 = valueFactory.instance();
+		V value2 = valueFactory.instance();
+		V value3 = valueFactory.instance();
+
+		zSetOps.add(key, value1, 1.9);
+		zSetOps.add(key, value2, 3.7);
+		zSetOps.add(key, value3, 5.8);
+
+		Range<Double> range = Range.of(Range.Bound.inclusive(1.5), Range.Bound.exclusive(5.0));
+
+		Set<TypedTuple<V>> results = zSetOps.reverseRangeByScoreWithScores(key, range);
+
+		assertThat(results).hasSize(2)
+				.contains(new DefaultTypedTuple<>(value1, 1.9))
+				.contains(new DefaultTypedTuple<>(value2, 3.7));
+
+		assertThat(new ArrayList<>(results).get(0).getValue()).isEqualTo(value2);
+		assertThat(new ArrayList<>(results).get(1).getValue()).isEqualTo(value1);
+	}
+
+	@ParameterizedRedisTest // GH-3139
+	void testReverseRangeByScoreWithScoresWithRangeAndLimit() {
+
+		K key = keyFactory.instance();
+		V value1 = valueFactory.instance();
+		V value2 = valueFactory.instance();
+		V value3 = valueFactory.instance();
+		V value4 = valueFactory.instance();
+
+		zSetOps.add(key, value1, 1.0);
+		zSetOps.add(key, value2, 2.0);
+		zSetOps.add(key, value3, 3.0);
+		zSetOps.add(key, value4, 4.0);
+
+		Range<Double> range = Range.of(Range.Bound.inclusive(1.0), Range.Bound.inclusive(4.0));
+		Limit limit = Limit.limit().offset(1).count(2);
+
+		Set<TypedTuple<V>> results = zSetOps.reverseRangeByScoreWithScores(key, range, limit);
+
+		assertThat(results).hasSize(2)
+				.contains(new DefaultTypedTuple<>(value2, 2.0))
+				.contains(new DefaultTypedTuple<>(value3, 3.0));
+
+		assertThat(new ArrayList<>(results).get(0).getValue()).isEqualTo(value3);
+		assertThat(new ArrayList<>(results).get(1).getValue()).isEqualTo(value2);
+	}
+
 }

src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsUnitTests.java

@@ -31,6 +31,7 @@
  * Unit tests for {@link DefaultZSetOperations}.
  *
  * @author Christoph Strobl
+ * @author Kim Sumin
  */
 class DefaultZSetOperationsUnitTests {
 
@@ -69,4 +70,42 @@ void delegatesAddIfAbsentForTuples() {
 
 		template.verify().zAdd(eq(template.serializeKey("key")), any(Set.class), eq(ZAddArgs.ifNotExists()));
 	}
+
+	@Test // GH-3139
+	void delegatesRangeByScoreWithScoresWithRange() {
+
+		Range<Double> range = Range.closed(1.0, 3.0);
+		zSetOperations.rangeByScoreWithScores("key", range);
+
+		template.verify().zRangeByScoreWithScores(eq(template.serializeKey("key")), eq(range));
+	}
+
+	@Test // GH-3139
+	void delegatesRangeByScoreWithScoresWithRangeAndLimit() {
+
+		Range<Double> range = Range.closed(1.0, 3.0);
+		org.springframework.data.redis.connection.Limit limit = org.springframework.data.redis.connection.Limit.limit().offset(1).count(2);
+		zSetOperations.rangeByScoreWithScores("key", range, limit);
+
+		template.verify().zRangeByScoreWithScores(eq(template.serializeKey("key")), eq(range), eq(limit));
+	}
+
+	@Test // GH-3139
+	void delegatesReverseRangeByScoreWithScoresWithRange() {
+
+		Range<Double> range = Range.closed(1.0, 3.0);
+		zSetOperations.reverseRangeByScoreWithScores("key", range);
+
+		template.verify().zRevRangeByScoreWithScores(eq(template.serializeKey("key")), eq(range));
+	}
+
+	@Test // GH-3139
+	void delegatesReverseRangeByScoreWithScoresWithRangeAndLimit() {
+
+		Range<Double> range = Range.closed(1.0, 3.0);
+		org.springframework.data.redis.connection.Limit limit = org.springframework.data.redis.connection.Limit.limit().offset(1).count(2);
+		zSetOperations.reverseRangeByScoreWithScores("key", range, limit);
+
+		template.verify().zRevRangeByScoreWithScores(eq(template.serializeKey("key")), eq(range), eq(limit));
+	}
 }