From 4ab1789953cdf96d1a1d4cf5faaa8d5b33e6a3cc Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Tue, 29 Mar 2022 15:09:35 +0200 Subject: [PATCH] Use `o.s.d.d.Range` instead of inner `Range` class for ZSet operations. Closes: #2288 Original Pull Request: #2292 --- .../DefaultStringRedisConnection.java | 77 +++++++++++----- .../connection/DefaultedRedisConnection.java | 25 +++-- .../redis/connection/RedisZSetCommands.java | 92 +++++++++++++------ .../connection/StringRedisConnection.java | 16 ++-- .../jedis/JedisClusterZSetCommands.java | 76 +++++++++------ .../connection/jedis/JedisConverters.java | 41 +++++---- .../connection/jedis/JedisZSetCommands.java | 76 +++++++++------ .../connection/lettuce/LettuceConverters.java | 21 +++-- .../lettuce/LettuceZSetCommands.java | 24 +++-- .../data/redis/core/BoundZSetOperations.java | 30 +++--- .../redis/core/DefaultZSetOperations.java | 41 ++++++--- .../data/redis/core/ZSetOperations.java | 18 ++-- .../support/collections/DefaultRedisZSet.java | 10 +- .../redis/support/collections/RedisZSet.java | 33 +++---- .../AbstractConnectionIntegrationTests.java | 42 +++++---- .../connection/RedisConnectionUnitTests.java | 28 +++--- .../jedis/JedisClusterConnectionTests.java | 17 ++-- .../jedis/JedisConvertersUnitTests.java | 43 ++++----- .../LettuceClusterConnectionTests.java | 17 ++-- ...DefaultZSetOperationsIntegrationTests.java | 17 ++-- .../core/DefaultZSetOperationsUnitTests.java | 7 +- .../AbstractRedisZSetTestIntegration.java | 23 +++-- 22 files changed, 450 insertions(+), 324 deletions(-) diff --git a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java index 69d608c3e..5976e1ed6 100644 --- a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java @@ -25,6 +25,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.core.convert.converter.Converter; +import org.springframework.data.domain.Range; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; import org.springframework.data.geo.GeoResults; @@ -990,7 +991,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zCount(byte[] key, Range range) { + public Long zCount(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zCount(key, range), Converters.identityConverter()); } @@ -1100,17 +1101,18 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRangeByScore(byte[] key, Range range) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRangeByScore(key, range), Converters.identityConverter()); } @Override - public Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRangeByScore(key, range, limit), Converters.identityConverter()); } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range) { + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRangeByScoreWithScores(key, range), Converters.identityConverter()); } @@ -1126,7 +1128,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range, + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRangeByScoreWithScores(key, range, limit), Converters.identityConverter()); } @@ -1147,7 +1149,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRevRangeByScore(byte[] key, Range range) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRevRangeByScore(key, range), Converters.identityConverter()); } @@ -1157,7 +1159,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRevRangeByScore(key, range, limit), Converters.identityConverter()); } @@ -1168,12 +1171,12 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range) { + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRevRangeByScoreWithScores(key, range), Converters.identityConverter()); } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range, + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRevRangeByScoreWithScores(key, range, limit), Converters.identityConverter()); } @@ -1199,7 +1202,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zRemRangeByLex(byte[] key, Range range) { + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRemRangeByLex(key, range), Converters.identityConverter()); } @@ -1209,7 +1212,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zRemRangeByScore(byte[] key, Range range) { + public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRemRangeByScore(key, range), Converters.identityConverter()); } @@ -1291,8 +1294,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zLexCount(String key, Range range) { - return delegate.zLexCount(serialize(key), range); + public Long zLexCount(String key, org.springframework.data.domain.Range range) { + return delegate.zLexCount(serialize(key), serialize(range)); } @Override @@ -1370,6 +1373,26 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco return serializer.serialize(data); } + private org.springframework.data.domain.Range serialize(org.springframework.data.domain.Range range) { + + if (!range.getLowerBound().isBounded() && !range.getUpperBound().isBounded()) { + return org.springframework.data.domain.Range.unbounded(); + } + + org.springframework.data.domain.Range.Bound lower = rawBound(range.getLowerBound()); + org.springframework.data.domain.Range.Bound upper = rawBound(range.getUpperBound()); + + return org.springframework.data.domain.Range.of(lower, upper); + } + + private org.springframework.data.domain.Range.Bound rawBound( + org.springframework.data.domain.Range.Bound source) { + return source.getValue().map(this::serialize) + .map(it -> source.isInclusive() ? org.springframework.data.domain.Range.Bound.inclusive(it) + : org.springframework.data.domain.Range.Bound.exclusive(it)) + .orElseGet(org.springframework.data.domain.Range.Bound::unbounded); + } + @SuppressWarnings("unchecked") private GeoReference serialize(GeoReference data) { return data instanceof GeoReference.GeoMemberReference @@ -1987,7 +2010,7 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zLexCount(byte[] key, Range range) { + public Long zLexCount(byte[] key, org.springframework.data.domain.Range range) { return delegate.zLexCount(key, range); } @@ -2165,8 +2188,8 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Long zRemRangeByLex(String key, Range range) { - return zRemRangeByLex(serialize(key), range); + public Long zRemRangeByLex(String key, org.springframework.data.domain.Range range) { + return zRemRangeByLex(serialize(key), serialize(range)); } @Override @@ -2655,38 +2678,42 @@ public class DefaultStringRedisConnection implements StringRedisConnection, Deco } @Override - public Set zRangeByLex(byte[] key, Range range) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return convertAndReturn(delegate.zRangeByLex(key, range), Converters.identityConverter()); } @Override - public Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRangeByLex(key, range, limit), Converters.identityConverter()); } @Override public Set zRangeByLex(String key) { - return zRangeByLex(key, Range.unbounded()); + return zRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } @Override - public Set zRangeByLex(String key, Range range) { + public Set zRangeByLex(String key, org.springframework.data.domain.Range range) { return zRangeByLex(key, range, org.springframework.data.redis.connection.Limit.unlimited()); } @Override - public Set zRangeByLex(String key, Range range, org.springframework.data.redis.connection.Limit limit) { - return convertAndReturn(delegate.zRangeByLex(serialize(key), range, limit), byteSetToStringSet); + public Set zRangeByLex(String key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { + return convertAndReturn(delegate.zRangeByLex(serialize(key), serialize(range), limit), byteSetToStringSet); } @Override - public Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return convertAndReturn(delegate.zRevRangeByLex(key, range, limit), Converters.identityConverter()); } @Override - public Set zRevRangeByLex(String key, Range range, org.springframework.data.redis.connection.Limit limit) { - return convertAndReturn(delegate.zRevRangeByLex(serialize(key), range, limit), byteSetToStringSet); + public Set zRevRangeByLex(String key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { + return convertAndReturn(delegate.zRevRangeByLex(serialize(key), serialize(range), limit), byteSetToStringSet); } @Override diff --git a/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java index 801d4b19f..1968d5ea7 100644 --- a/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java @@ -23,6 +23,7 @@ import java.util.Properties; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; import org.springframework.data.geo.GeoResults; @@ -967,7 +968,7 @@ public interface DefaultedRedisConnection extends RedisCommands, RedisCommandsPr /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Long zLexCount(byte[] key, Range range) { + default Long zLexCount(byte[] key, org.springframework.data.domain.Range range) { return zSetCommands().zLexCount(key, range); } @@ -1016,7 +1017,7 @@ public interface DefaultedRedisConnection extends RedisCommands, RedisCommandsPr /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Long zCount(byte[] key, Range range) { + default Long zCount(byte[] key, org.springframework.data.domain.Range range) { return zSetCommands().zCount(key, range); } @@ -1142,28 +1143,31 @@ public interface DefaultedRedisConnection extends RedisCommands, RedisCommandsPr /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + default Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRangeByLex(key, range, limit); } /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + default Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRevRangeByLex(key, range, limit); } /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + default Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRangeByScore(key, range, limit); } /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRangeByScoreWithScores(byte[] key, Range range, + default Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRangeByScoreWithScores(key, range, limit); } @@ -1178,14 +1182,15 @@ public interface DefaultedRedisConnection extends RedisCommands, RedisCommandsPr /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + default Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRevRangeByScore(key, range, limit); } /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Set zRevRangeByScoreWithScores(byte[] key, Range range, + default Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return zSetCommands().zRevRangeByScoreWithScores(key, range, limit); } @@ -1214,14 +1219,14 @@ public interface DefaultedRedisConnection extends RedisCommands, RedisCommandsPr /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Long zRemRangeByLex(byte[] key, Range range) { + default Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return zSetCommands().zRemRangeByLex(key, range); } /** @deprecated in favor of {@link RedisConnection#zSetCommands()}}. */ @Override @Deprecated - default Long zRemRangeByScore(byte[] key, Range range) { + default Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return zSetCommands().zRemRangeByScore(key, range); } diff --git a/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java index a85be1de7..346fd13a2 100644 --- a/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java @@ -52,7 +52,9 @@ public interface RedisZSetCommands { * * @author Christoph Strobl * @since 1.6 + * @deprecated since 3.0, use {@link org.springframework.data.domain.Range} or {@link #toRange()} instead. */ + @Deprecated class Range { @Nullable Boundary min; @@ -172,6 +174,30 @@ public interface RedisZSetCommands { } } + /** + * Create a {@link org.springframework.data.domain.Range} object from this range. + * + * @return a {@link org.springframework.data.domain.Range} object using bounds from this range. + * @since 3.0 + */ + public org.springframework.data.domain.Range toRange() { + + org.springframework.data.domain.Range.Bound lower = toBound(min); + org.springframework.data.domain.Range.Bound upper = toBound(max); + + return (org.springframework.data.domain.Range) org.springframework.data.domain.Range.from(lower).to(upper); + } + + private org.springframework.data.domain.Range.Bound toBound(@Nullable Boundary boundary) { + + if (boundary == null || boundary.value == null) { + return org.springframework.data.domain.Range.Bound.unbounded(); + } + + return boundary.isIncluding() ? org.springframework.data.domain.Range.Bound.inclusive(boundary.getValue()) + : org.springframework.data.domain.Range.Bound.exclusive(boundary.getValue()); + } + } /** @@ -532,7 +558,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRangeByScore(byte[] key, double min, double max) { - return zRangeByScore(key, new Range().gte(min).lte(max)); + return zRangeByScore(key, org.springframework.data.domain.Range.closed(min, max)); } /** @@ -546,7 +572,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYSCORE */ @Nullable - default Set zRangeByScoreWithScores(byte[] key, Range range) { + default Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return zRangeByScoreWithScores(key, range, Limit.unlimited()); } @@ -562,7 +588,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRangeByScoreWithScores(byte[] key, double min, double max) { - return zRangeByScoreWithScores(key, new Range().gte(min).lte(max)); + return zRangeByScoreWithScores(key, org.springframework.data.domain.Range.closed(min, max)); } /** @@ -580,7 +606,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRangeByScore(byte[] key, double min, double max, long offset, long count) { - return zRangeByScore(key, new Range().gte(min).lte(max), + return zRangeByScore(key, org.springframework.data.domain.Range.closed(min, max), new org.springframework.data.redis.connection.Limit().offset(Long.valueOf(offset).intValue()) .count(Long.valueOf(count).intValue())); } @@ -600,7 +626,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) { - return zRangeByScoreWithScores(key, new Range().gte(min).lte(max), + return zRangeByScoreWithScores(key, org.springframework.data.domain.Range.closed(min, max), new org.springframework.data.redis.connection.Limit().offset(Long.valueOf(offset).intValue()) .count(Long.valueOf(count).intValue())); } @@ -618,7 +644,8 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYSCORE */ @Nullable - Set zRangeByScoreWithScores(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Get elements in range from {@code start} to {@code end} from sorted set ordered from high to low. @@ -658,7 +685,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRevRangeByScore(byte[] key, double min, double max) { - return zRevRangeByScore(key, new Range().gte(min).lte(max)); + return zRevRangeByScore(key, org.springframework.data.domain.Range.closed(min, max)); } /** @@ -673,7 +700,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYSCORE */ @Nullable - default Set zRevRangeByScore(byte[] key, Range range) { + default Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return zRevRangeByScore(key, range, Limit.unlimited()); } @@ -690,7 +717,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRevRangeByScoreWithScores(byte[] key, double min, double max) { - return zRevRangeByScoreWithScores(key, new Range().gte(min).lte(max), Limit.unlimited()); + return zRevRangeByScoreWithScores(key, org.springframework.data.domain.Range.closed(min, max), Limit.unlimited()); } /** @@ -708,7 +735,7 @@ public interface RedisZSetCommands { @Nullable default Set zRevRangeByScore(byte[] key, double min, double max, long offset, long count) { - return zRevRangeByScore(key, new Range().gte(min).lte(max), + return zRevRangeByScore(key, org.springframework.data.domain.Range.closed(min, max), new Limit().offset(Long.valueOf(offset).intValue()).count(Long.valueOf(count).intValue())); } @@ -724,7 +751,8 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYSCORE */ @Nullable - Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Get set of {@link Tuple} in range from {@code start} to {@code end} where score is between {@code min} and @@ -741,7 +769,7 @@ public interface RedisZSetCommands { @Nullable default Set zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) { - return zRevRangeByScoreWithScores(key, new Range().gte(min).lte(max), + return zRevRangeByScoreWithScores(key, org.springframework.data.domain.Range.closed(min, max), new org.springframework.data.redis.connection.Limit().offset(Long.valueOf(offset).intValue()) .count(Long.valueOf(count).intValue())); } @@ -757,7 +785,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYSCORE */ @Nullable - default Set zRevRangeByScoreWithScores(byte[] key, Range range) { + default Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return zRevRangeByScoreWithScores(key, range, Limit.unlimited()); } @@ -773,7 +801,8 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYSCORE */ @Nullable - Set zRevRangeByScoreWithScores(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Count number of elements within sorted set with scores between {@code min} and {@code max}. @@ -786,7 +815,7 @@ public interface RedisZSetCommands { */ @Nullable default Long zCount(byte[] key, double min, double max) { - return zCount(key, new Range().gte(min).lte(max)); + return zCount(key, org.springframework.data.domain.Range.closed(min, max)); } /** @@ -799,7 +828,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZCOUNT */ @Nullable - Long zCount(byte[] key, Range range); + Long zCount(byte[] key, org.springframework.data.domain.Range range); /** * Count number of elements within sorted set with value between {@code Range#min} and {@code Range#max} applying @@ -812,7 +841,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZLEXCOUNT */ @Nullable - Long zLexCount(byte[] key, Range range); + Long zLexCount(byte[] key, org.springframework.data.domain.Range range); /** * Remove and return the value with its score having the lowest score from sorted set at {@code key}. @@ -942,7 +971,7 @@ public interface RedisZSetCommands { * @since 2.5 * @see Redis Documentation: ZREMRANGEBYLEX */ - Long zRemRangeByLex(byte[] key, Range range); + Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with {@code key}. @@ -955,7 +984,7 @@ public interface RedisZSetCommands { */ @Nullable default Long zRemRangeByScore(byte[] key, double min, double max) { - return zRemRangeByScore(key, new Range().gte(min).lte(max)); + return zRemRangeByScore(key, org.springframework.data.domain.Range.closed(min, max)); } /** @@ -968,7 +997,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREMRANGEBYSCORE */ @Nullable - Long zRemRangeByScore(byte[] key, Range range); + Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range); /** * Diff sorted {@code sets}. @@ -1203,10 +1232,12 @@ public interface RedisZSetCommands { * @return {@literal null} when used in pipeline / transaction. * @since 1.5 * @see Redis Documentation: ZRANGEBYSCORE + * @deprecated since 3.0, use {@link #zRangeByScore(byte[], org.springframework.data.domain.Range)} instead. */ @Nullable + @Deprecated default Set zRangeByScore(byte[] key, String min, String max) { - return zRangeByScore(key, new Range().gte(min).lte(max)); + return zRangeByScore(key, new Range().gte(min).lte(max).toRange()); } /** @@ -1219,7 +1250,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYSCORE */ @Nullable - default Set zRangeByScore(byte[] key, Range range) { + default Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return zRangeByScore(key, range, Limit.unlimited()); } @@ -1251,7 +1282,8 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYSCORE */ @Nullable - Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Get all the elements in the sorted set at {@literal key} in lexicographical ordering. @@ -1263,7 +1295,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRangeByLex(byte[] key) { - return zRangeByLex(key, Range.unbounded()); + return zRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** @@ -1276,7 +1308,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - default Set zRangeByLex(byte[] key, Range range) { + default Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return zRangeByLex(key, range, Limit.unlimited()); } @@ -1292,7 +1324,8 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Get all the elements in the sorted set at {@literal key} in reversed lexicographical ordering. @@ -1304,7 +1337,7 @@ public interface RedisZSetCommands { */ @Nullable default Set zRevRangeByLex(byte[] key) { - return zRevRangeByLex(key, Range.unbounded()); + return zRevRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** @@ -1317,7 +1350,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - default Set zRevRangeByLex(byte[] key, Range range) { + default Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return zRevRangeByLex(key, range, org.springframework.data.redis.connection.Limit.unlimited()); } @@ -1333,6 +1366,7 @@ public interface RedisZSetCommands { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); } diff --git a/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java b/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java index 8a71eed03..a217fc282 100644 --- a/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java @@ -1538,7 +1538,7 @@ public interface StringRedisConnection extends RedisConnection { * @see RedisZSetCommands#zLexCount(byte[], Range) */ @Nullable - Long zLexCount(String key, Range range); + Long zLexCount(String key, org.springframework.data.domain.Range range); /** * Remove and return the value with its score having the lowest score from sorted set at {@code key}. @@ -1669,7 +1669,7 @@ public interface StringRedisConnection extends RedisConnection { * @since 2.5 * @see Redis Documentation: ZREMRANGEBYLEX */ - Long zRemRangeByLex(String key, Range range); + Long zRemRangeByLex(String key, org.springframework.data.domain.Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with {@code key}. @@ -1927,7 +1927,7 @@ public interface StringRedisConnection extends RedisConnection { * @see Redis Documentation: ZRANGEBYLEX * @see RedisZSetCommands#zRangeByLex(byte[], Range) */ - Set zRangeByLex(String key, Range range); + Set zRangeByLex(String key, org.springframework.data.domain.Range range); /** * Get all the elements in {@link Range} from the sorted set at {@literal key} in lexicographical ordering. Result is @@ -1941,7 +1941,8 @@ public interface StringRedisConnection extends RedisConnection { * @see Redis Documentation: ZRANGEBYLEX * @see RedisZSetCommands#zRangeByLex(byte[], Range, Limit) */ - Set zRangeByLex(String key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRangeByLex(String key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); /** * Get all the elements in the sorted set at {@literal key} in reversed lexicographical ordering. @@ -1953,7 +1954,7 @@ public interface StringRedisConnection extends RedisConnection { * @see RedisZSetCommands#zRevRangeByLex(byte[]) */ default Set zRevRangeByLex(String key) { - return zRevRangeByLex(key, Range.unbounded()); + return zRevRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** @@ -1966,7 +1967,7 @@ public interface StringRedisConnection extends RedisConnection { * @see Redis Documentation: ZREVRANGEBYLEX * @see RedisZSetCommands#zRevRangeByLex(byte[], Range) */ - default Set zRevRangeByLex(String key, Range range) { + default Set zRevRangeByLex(String key, org.springframework.data.domain.Range range) { return zRevRangeByLex(key, range, org.springframework.data.redis.connection.Limit.unlimited()); } @@ -1982,7 +1983,8 @@ public interface StringRedisConnection extends RedisConnection { * @see Redis Documentation: ZREVRANGEBYLEX * @see RedisZSetCommands#zRevRangeByLex(byte[], Range, Limit) */ - Set zRevRangeByLex(String key, Range range, org.springframework.data.redis.connection.Limit limit); + Set zRevRangeByLex(String key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit); // ------------------------------------------------------------------------- // Methods dealing with Redis Hashes diff --git a/src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java index e4376b14b..c44416670 100644 --- a/src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java @@ -205,14 +205,16 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range, + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZRANGEBYSCOREWITHSCORES."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { if (limit.isUnlimited()) { @@ -226,13 +228,16 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCORE."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { if (limit.isUnlimited()) { @@ -246,14 +251,16 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range, + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZREVRANGEBYSCOREWITHSCORES."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { if (limit.isUnlimited()) { @@ -267,13 +274,15 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Long zCount(byte[] key, Range range) { + public Long zCount(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZCOUNT."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { return connection.getCluster().zcount(key, min, max); @@ -283,13 +292,13 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Long zLexCount(byte[] key, Range range) { + public Long zLexCount(byte[] key, org.springframework.data.domain.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); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); try { return connection.getCluster().zlexcount(key, min, max); @@ -381,13 +390,15 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Long zRemRangeByScore(byte[] key, Range range) { + public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZREMRANGEBYSCORE."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { return connection.getCluster().zremrangeByScore(key, min, max); @@ -398,13 +409,16 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range cannot be null for ZRANGEBYSCORE."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); try { if (limit.isUnlimited()) { @@ -418,14 +432,15 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null for ZRANGEBYLEX!"); Assert.notNull(limit, "Limit must not be null!"); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); try { if (limit.isUnlimited()) { @@ -439,13 +454,13 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Long zRemRangeByLex(byte[] key, Range range) { + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null for ZREMRANGEBYLEX!"); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); try { return connection.getCluster().zremrangeByLex(key, min, max); @@ -455,14 +470,15 @@ class JedisClusterZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null for ZREVRANGEBYLEX!"); Assert.notNull(limit, "Limit must not be null!"); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); try { if (limit.isUnlimited()) { diff --git a/src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java b/src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java index 8b72d3fd0..429a143d0 100644 --- a/src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java +++ b/src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java @@ -63,7 +63,6 @@ import org.springframework.data.redis.connection.RedisServer; import org.springframework.data.redis.connection.RedisServerCommands; import org.springframework.data.redis.connection.RedisStringCommands.BitOperation; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; -import org.springframework.data.redis.connection.RedisZSetCommands.Range.Boundary; import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs; import org.springframework.data.redis.connection.SortParameters; import org.springframework.data.redis.connection.SortParameters.Order; @@ -304,7 +303,7 @@ abstract class JedisConverters extends Converters { } /** - * Converts a given {@link Boundary} to its binary representation suitable for {@literal ZRANGEBY*} commands, despite + * Converts a given {@link Bound} to its binary representation suitable for {@literal ZRANGEBY*} commands, despite * {@literal ZRANGEBYLEX}. * * @param boundary @@ -312,9 +311,10 @@ abstract class JedisConverters extends Converters { * @return * @since 1.6 */ - public static byte[] boundaryToBytesForZRange(@Nullable Boundary boundary, byte[] defaultValue) { + public static byte[] boundaryToBytesForZRange(@Nullable org.springframework.data.domain.Range.Bound boundary, + byte[] defaultValue) { - if (boundary == null || boundary.getValue() == null) { + if (boundary == null || !boundary.isBounded()) { return defaultValue; } @@ -322,15 +322,16 @@ abstract class JedisConverters extends Converters { } /** - * Converts a given {@link Boundary} to its binary representation suitable for ZRANGEBYLEX command. + * Converts a given {@link Bound} to its binary representation suitable for ZRANGEBYLEX command. * * @param boundary * @return * @since 1.6 */ - public static byte[] boundaryToBytesForZRangeByLex(@Nullable Boundary boundary, byte[] defaultValue) { + public static byte[] boundaryToBytesForZRangeByLex( + @Nullable org.springframework.data.domain.Range.Bound boundary, byte[] defaultValue) { - if (boundary == null || boundary.getValue() == null) { + if (boundary == null || !boundary.isBounded()) { return defaultValue; } @@ -471,20 +472,22 @@ abstract class JedisConverters extends Converters { } } - private static byte[] boundaryToBytes(Boundary boundary, byte[] inclPrefix, byte[] exclPrefix) { + private static byte[] boundaryToBytes(org.springframework.data.domain.Range.Bound boundary, byte[] inclPrefix, + byte[] exclPrefix) { - byte[] prefix = boundary.isIncluding() ? inclPrefix : exclPrefix; + byte[] prefix = boundary.isInclusive() ? inclPrefix : exclPrefix; byte[] value = null; - if (boundary.getValue() instanceof byte[]) { - value = (byte[]) boundary.getValue(); - } else if (boundary.getValue() instanceof Double) { - value = toBytes((Double) boundary.getValue()); - } else if (boundary.getValue() instanceof Long) { - value = toBytes((Long) boundary.getValue()); - } else if (boundary.getValue() instanceof Integer) { - value = toBytes((Integer) boundary.getValue()); - } else if (boundary.getValue() instanceof String) { - value = toBytes((String) boundary.getValue()); + Object theValue = boundary.getValue().get(); + if (theValue instanceof byte[]) { + value = (byte[]) theValue; + } else if (theValue instanceof Double) { + value = toBytes((Double) theValue); + } else if (theValue instanceof Long) { + value = toBytes((Long) theValue); + } else if (theValue instanceof Integer) { + value = toBytes((Integer) theValue); + } else if (theValue instanceof String) { + value = toBytes((String) theValue); } else { throw new IllegalArgumentException(String.format("Cannot convert %s to binary format", boundary.getValue())); } diff --git a/src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java index 347089639..5a2749483 100644 --- a/src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java @@ -171,15 +171,17 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range, + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZRANGEBYSCOREWITHSCORES must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); if (!limit.isUnlimited()) { return connection.invoke().fromMany(Jedis::zrangeByScoreWithScores, @@ -211,14 +213,17 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREVRANGEBYSCORE must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); if (!limit.isUnlimited()) { return connection.invoke().fromMany(Jedis::zrevrangeByScore, PipelineBinaryCommands::zrevrangeByScore, key, max, @@ -230,15 +235,17 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range, + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREVRANGEBYSCOREWITHSCORES must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); if (!limit.isUnlimited()) { return connection.invoke().fromMany(Jedis::zrevrangeByScoreWithScores, @@ -260,25 +267,27 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Long zCount(byte[] key, Range range) { + public Long zCount(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); return connection.invoke().just(Jedis::zcount, PipelineBinaryCommands::zcount, key, min, max); } @Override - public Long zLexCount(byte[] key, Range range) { + public Long zLexCount(byte[] key, org.springframework.data.domain.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); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); return connection.invoke().just(Jedis::zlexcount, PipelineBinaryCommands::zlexcount, key, min, max); } @@ -380,25 +389,27 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Long zRemRangeByLex(byte[] key, Range range) { + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null for ZREMRANGEBYLEX!"); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); return connection.invoke().just(Jedis::zremrangeByLex, PipelineBinaryCommands::zremrangeByLex, key, min, max); } @Override - public Long zRemRangeByScore(byte[] key, Range range) { + public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREMRANGEBYSCORE must not be null!"); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); return connection.invoke().just(Jedis::zremrangeByScore, PipelineBinaryCommands::zremrangeByScore, key, min, max); } @@ -604,14 +615,17 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZRANGEBYSCORE must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRange(range.getMin(), JedisConverters.NEGATIVE_INFINITY_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRange(range.getMax(), JedisConverters.POSITIVE_INFINITY_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRange(range.getLowerBound(), + JedisConverters.NEGATIVE_INFINITY_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRange(range.getUpperBound(), + JedisConverters.POSITIVE_INFINITY_BYTES); if (!limit.isUnlimited()) { return connection.invoke().fromMany(Jedis::zrangeByScore, PipelineBinaryCommands::zrangeByScore, key, min, max, @@ -623,14 +637,15 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZRANGEBYLEX must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); if (!limit.isUnlimited()) { return connection.invoke().fromMany(Jedis::zrangeByLex, PipelineBinaryCommands::zrangeByLex, key, min, max, @@ -641,14 +656,15 @@ class JedisZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREVRANGEBYLEX must not be null!"); Assert.notNull(limit, "Limit must not be null! Use Limit.unlimited() instead."); - byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES); - byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES); + byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getLowerBound(), JedisConverters.MINUS_BYTES); + byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getUpperBound(), JedisConverters.PLUS_BYTES); if (!limit.isUnlimited()) { return connection.invoke().from(Jedis::zrevrangeByLex, PipelineBinaryCommands::zrevrangeByLex, key, max, min, diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java index f2322f042..bdb9387a6 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceConverters.java @@ -289,7 +289,7 @@ public abstract class LettuceConverters extends Converters { * @return * @since 2.0 */ - public static Range toRange(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + public static Range toRange(org.springframework.data.domain.Range range) { return Range.from(lowerBoundaryOf(range, false), upperBoundaryOf(range, false)); } @@ -301,7 +301,7 @@ public abstract class LettuceConverters extends Converters { * @return * @since 2.2 */ - public static Range toRange(org.springframework.data.redis.connection.RedisZSetCommands.Range range, + public static Range toRange(org.springframework.data.domain.Range range, boolean convertNumberToBytes) { return Range.from(lowerBoundaryOf(range, convertNumberToBytes), upperBoundaryOf(range, convertNumberToBytes)); } @@ -314,34 +314,35 @@ public abstract class LettuceConverters extends Converters { * @return * @since 2.0 */ - public static Range toRevRange(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + public static Range toRevRange(org.springframework.data.domain.Range range) { return Range.from(upperBoundaryOf(range, false), lowerBoundaryOf(range, false)); } @SuppressWarnings("unchecked") private static Range.Boundary lowerBoundaryOf( - org.springframework.data.redis.connection.RedisZSetCommands.Range range, boolean convertNumberToBytes) { + org.springframework.data.domain.Range range, boolean convertNumberToBytes) { return (Range.Boundary) rangeToBoundaryArgumentConverter(false, convertNumberToBytes).convert(range); } @SuppressWarnings("unchecked") private static Range.Boundary upperBoundaryOf( - org.springframework.data.redis.connection.RedisZSetCommands.Range range, boolean convertNumberToBytes) { + org.springframework.data.domain.Range range, boolean convertNumberToBytes) { return (Range.Boundary) rangeToBoundaryArgumentConverter(true, convertNumberToBytes).convert(range); } - private static Converter> rangeToBoundaryArgumentConverter( + private static Converter, Range.Boundary> rangeToBoundaryArgumentConverter( boolean upper, boolean convertNumberToBytes) { return (source) -> { - Boundary sourceBoundary = upper ? source.getMax() : source.getMin(); - if (sourceBoundary == null || sourceBoundary.getValue() == null) { + org.springframework.data.domain.Range.Bound sourceBoundary = upper ? source.getUpperBound() + : source.getLowerBound(); + if (sourceBoundary == null || !sourceBoundary.isBounded()) { return Range.Boundary.unbounded(); } - boolean inclusive = sourceBoundary.isIncluding(); - Object value = sourceBoundary.getValue(); + boolean inclusive = sourceBoundary.isInclusive(); + Object value = sourceBoundary.getValue().get(); if (value instanceof Number) { diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java index d57746f64..bf8694c77 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java @@ -164,7 +164,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range, + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); @@ -202,7 +202,8 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREVRANGEBYSCORE must not be null!"); @@ -221,7 +222,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range, + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); @@ -241,7 +242,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Long zCount(byte[] key, Range range) { + public Long zCount(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); @@ -250,7 +251,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Long zLexCount(byte[] key, Range range) { + public Long zLexCount(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null!"); @@ -370,7 +371,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Long zRemRangeByLex(byte[] key, Range range) { + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range must not be null for ZREMRANGEBYLEX!"); @@ -380,7 +381,7 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Long zRemRangeByScore(byte[] key, Range range) { + public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREMRANGEBYSCORE must not be null!"); @@ -589,7 +590,8 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZRANGEBYSCORE must not be null!"); @@ -605,7 +607,8 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZRANGEBYLEX must not be null!"); @@ -622,7 +625,8 @@ class LettuceZSetCommands implements RedisZSetCommands { } @Override - public Set zRevRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { Assert.notNull(key, "Key must not be null!"); Assert.notNull(range, "Range for ZREVRANGEBYLEX must not be null!"); diff --git a/src/main/java/org/springframework/data/redis/core/BoundZSetOperations.java b/src/main/java/org/springframework/data/redis/core/BoundZSetOperations.java index 2dc8433ec..ee33b17f7 100644 --- a/src/main/java/org/springframework/data/redis/core/BoundZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/BoundZSetOperations.java @@ -22,9 +22,9 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.ZSetOperations.TypedTuple; @@ -303,7 +303,7 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZLEXCOUNT */ @Nullable - Long lexCount(Range range); + Long lexCount(Range range); /** * Remove and return the value with its score having the lowest score from sorted set at the bound key. @@ -472,7 +472,7 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZREMRANGEBYLEX */ @Nullable - Long removeRangeByLex(Range range); + Long removeRangeByLex(Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with the bound key. @@ -805,8 +805,8 @@ public interface BoundZSetOperations extends BoundKeyOperations { Cursor> scan(ScanOptions options); /** - * Get all elements with lexicographical ordering with a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * Get all elements with lexicographical ordering with a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. @@ -814,14 +814,14 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - default Set rangeByLex(Range range) { + default Set rangeByLex(Range range) { return rangeByLex(range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at - * {@link Limit#getOffset()} with lexicographical ordering having a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * {@link Limit#getOffset()} with lexicographical ordering having a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. @@ -830,11 +830,11 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - Set rangeByLex(Range range, Limit limit); + Set rangeByLex(Range range, Limit limit); /** - * Get all elements with reverse lexicographical ordering with a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * Get all elements with reverse lexicographical ordering with a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. @@ -842,14 +842,14 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - default Set reverseRangeByLex(Range range) { + default Set reverseRangeByLex(Range range) { return reverseRangeByLex(range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at - * {@link Limit#getOffset()} with reverse lexicographical ordering having a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * {@link Limit#getOffset()} with reverse lexicographical ordering having a value between + * {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. @@ -858,7 +858,7 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - Set reverseRangeByLex(Range range, Limit limit); + Set reverseRangeByLex(Range range, Limit limit); /** * @return never {@literal null}. diff --git a/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java b/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java index e04838179..b9d99efd3 100644 --- a/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java @@ -22,9 +22,9 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; @@ -209,19 +209,19 @@ class DefaultZSetOperations extends AbstractOperations implements ZS } @Override - public Set rangeByLex(K key, Range range, Limit limit) { + public Set rangeByLex(K key, Range range, Limit limit) { byte[] rawKey = rawKey(key); - Set rawValues = execute(connection -> connection.zRangeByLex(rawKey, range, limit)); + Set rawValues = execute(connection -> connection.zRangeByLex(rawKey, serialize(range), limit)); return deserializeValues(rawValues); } @Override - public Set reverseRangeByLex(K key, Range range, Limit limit) { + public Set reverseRangeByLex(K key, Range range, Limit limit) { byte[] rawKey = rawKey(key); - Set rawValues = execute(connection -> connection.zRevRangeByLex(rawKey, range, limit)); + Set rawValues = execute(connection -> connection.zRevRangeByLex(rawKey, serialize(range), limit)); return deserializeValues(rawValues); } @@ -340,10 +340,10 @@ class DefaultZSetOperations extends AbstractOperations implements ZS } @Override - public Long removeRangeByLex(K key, Range range) { + public Long removeRangeByLex(K key, Range range) { byte[] rawKey = rawKey(key); - return execute(connection -> connection.zRemRangeByLex(rawKey, range)); + return execute(connection -> connection.zRemRangeByLex(rawKey, serialize(range))); } @Override @@ -377,10 +377,10 @@ class DefaultZSetOperations extends AbstractOperations implements ZS } @Override - public Long lexCount(K key, Range range) { + public Long lexCount(K key, Range range) { byte[] rawKey = rawKey(key); - return execute(connection -> connection.zLexCount(rawKey, range)); + return execute(connection -> connection.zLexCount(rawKey, serialize(range))); } @Nullable @@ -397,7 +397,7 @@ class DefaultZSetOperations extends AbstractOperations implements ZS byte[] rawKey = rawKey(key); Set result = execute(connection -> connection.zPopMin(rawKey, count)); - return deserializeTupleValues(new LinkedHashSet<> (result)); + return deserializeTupleValues(new LinkedHashSet<>(result)); } @Nullable @@ -538,8 +538,7 @@ class DefaultZSetOperations extends AbstractOperations implements ZS byte[][] rawKeys = rawKeys(key, otherKeys); Set result = execute(connection -> connection.zUnionWithScores(aggregate, weights, rawKeys)); - return deserializeTupleValues( - result); + return deserializeTupleValues(result); } @Override @@ -587,4 +586,22 @@ class DefaultZSetOperations extends AbstractOperations implements ZS return execute(connection -> connection.zRangeByScore(rawKey, min, max, offset, count)); } + private Range serialize(Range range) { + + if (!range.getLowerBound().isBounded() && !range.getUpperBound().isBounded()) { + return Range.unbounded(); + } + + Range.Bound lower = rawBound(range.getLowerBound()); + Range.Bound upper = rawBound(range.getUpperBound()); + + return Range.of(lower, upper); + } + + private Range.Bound rawBound(Range.Bound source) { + return source.getValue().map(this::rawString) + .map(it -> source.isInclusive() ? Range.Bound.inclusive(it) : Range.Bound.exclusive(it)) + .orElseGet(Range.Bound::unbounded); + } + } diff --git a/src/main/java/org/springframework/data/redis/core/ZSetOperations.java b/src/main/java/org/springframework/data/redis/core/ZSetOperations.java index 280d32550..fd5e72d10 100644 --- a/src/main/java/org/springframework/data/redis/core/ZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/ZSetOperations.java @@ -22,9 +22,9 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.lang.Nullable; @@ -402,8 +402,8 @@ public interface ZSetOperations { Long count(K key, double min, double max); /** - * Count number of elements within sorted set with value between {@code Range#min} and {@code Range#max} applying - * lexicographical ordering. + * Count number of elements within sorted set with value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()} applying lexicographical ordering. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -412,7 +412,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZLEXCOUNT */ @Nullable - Long lexCount(K key, Range range); + Long lexCount(K key, Range range); /** * Remove and return the value with its score having the lowest score from sorted set at {@code key}. @@ -595,7 +595,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZREMRANGEBYLEX */ @Nullable - Long removeRangeByLex(K key, Range range); + Long removeRangeByLex(K key, org.springframework.data.domain.Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with {@code key}. @@ -970,7 +970,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - default Set rangeByLex(K key, Range range) { + default Set rangeByLex(K key, org.springframework.data.domain.Range range) { return rangeByLex(key, range, Limit.unlimited()); } @@ -987,7 +987,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - Set rangeByLex(K key, Range range, Limit limit); + Set rangeByLex(K key, org.springframework.data.domain.Range range, Limit limit); /** * Get all elements with reverse lexicographical ordering from {@literal ZSET} at {@code key} with a value between @@ -1000,7 +1000,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - default Set reverseRangeByLex(K key, Range range) { + default Set reverseRangeByLex(K key, org.springframework.data.domain.Range range) { return reverseRangeByLex(key, range, Limit.unlimited()); } @@ -1017,7 +1017,7 @@ public interface ZSetOperations { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - Set reverseRangeByLex(K key, Range range, Limit limit); + Set reverseRangeByLex(K key, org.springframework.data.domain.Range range, Limit limit); /** * @return never {@literal null}. diff --git a/src/main/java/org/springframework/data/redis/support/collections/DefaultRedisZSet.java b/src/main/java/org/springframework/data/redis/support/collections/DefaultRedisZSet.java index f28421c2a..7ad7db419 100644 --- a/src/main/java/org/springframework/data/redis/support/collections/DefaultRedisZSet.java +++ b/src/main/java/org/springframework/data/redis/support/collections/DefaultRedisZSet.java @@ -21,9 +21,9 @@ import java.util.NoSuchElementException; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.connection.Limit; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.core.BoundZSetOperations; import org.springframework.data.redis.core.ConvertingCursor; import org.springframework.data.redis.core.Cursor; @@ -221,12 +221,12 @@ public class DefaultRedisZSet extends AbstractRedisCollection implements R } @Override - public Set rangeByLex(Range range, Limit limit) { + public Set rangeByLex(Range range, Limit limit) { return boundZSetOps.rangeByLex(range, limit); } @Override - public Set reverseRangeByLex(Range range, Limit limit) { + public Set reverseRangeByLex(Range range, Limit limit) { return boundZSetOps.reverseRangeByLex(range, limit); } @@ -267,7 +267,7 @@ public class DefaultRedisZSet extends AbstractRedisCollection implements R } @Override - public Set removeByLex(Range range) { + public Set removeByLex(Range range) { boundZSetOps.removeRangeByLex(range); return this; } @@ -424,7 +424,7 @@ public class DefaultRedisZSet extends AbstractRedisCollection implements R } @Override - public Long lexCount(Range range) { + public Long lexCount(Range range) { return boundZSetOps.lexCount(range); } diff --git a/src/main/java/org/springframework/data/redis/support/collections/RedisZSet.java b/src/main/java/org/springframework/data/redis/support/collections/RedisZSet.java index 3d2db6f58..1377914de 100644 --- a/src/main/java/org/springframework/data/redis/support/collections/RedisZSet.java +++ b/src/main/java/org/springframework/data/redis/support/collections/RedisZSet.java @@ -23,8 +23,8 @@ import java.util.Set; import java.util.SortedSet; import java.util.concurrent.TimeUnit; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.Limit; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.core.BoundZSetOperations; import org.springframework.data.redis.core.RedisOperations; @@ -263,22 +263,22 @@ public interface RedisZSet extends RedisCollection, Set { Set reverseRange(long start, long end); /** - * Get all elements with lexicographical ordering with a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * Get all elements with lexicographical ordering with a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @return * @see BoundZSetOperations#rangeByLex(Range) * @since 1.7 */ - default Set rangeByLex(Range range) { + default Set rangeByLex(Range range) { return rangeByLex(range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at - * {@link Limit#getOffset()} with lexicographical ordering having a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * {@link Limit#getOffset()} with lexicographical ordering having a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. @@ -286,25 +286,25 @@ public interface RedisZSet extends RedisCollection, Set { * @since 1.7 * @see BoundZSetOperations#rangeByLex(Range, Limit) */ - Set rangeByLex(Range range, Limit limit); + Set rangeByLex(Range range, Limit limit); /** - * Get all elements with reverse lexicographical ordering with a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * Get all elements with reverse lexicographical ordering with a value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @return * @since 2.4 * @see BoundZSetOperations#reverseRangeByLex(Range) */ - default Set reverseRangeByLex(Range range) { + default Set reverseRangeByLex(Range range) { return reverseRangeByLex(range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at - * {@link Limit#getOffset()} with reverse lexicographical ordering having a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * {@link Limit#getOffset()} with reverse lexicographical ordering having a value between + * {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. @@ -312,7 +312,7 @@ public interface RedisZSet extends RedisCollection, Set { * @since 2.4 * @see BoundZSetOperations#reverseRangeByLex(Range, Limit) */ - Set reverseRangeByLex(Range range, Limit limit); + Set reverseRangeByLex(Range range, Limit limit); /** * Get elements where score is between {@code min} and {@code max} from sorted set. @@ -386,7 +386,7 @@ public interface RedisZSet extends RedisCollection, Set { * @since 2.5 */ // TODO: Switch to RedisZSet - Set removeByLex(Range range); + Set removeByLex(Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with the bound key. @@ -413,7 +413,8 @@ public interface RedisZSet extends RedisCollection, Set { boolean add(E e); /** - * Adds an element to the set using the {@link #getDefaultScore() default score} if the element does not already exists. + * Adds an element to the set using the {@link #getDefaultScore() default score} if the element does not already + * exists. * * @param e element to add * @return true if a new element was added, false otherwise (only the score has been updated) @@ -442,7 +443,7 @@ public interface RedisZSet extends RedisCollection, Set { * @since 2.4 * @see Redis Documentation: ZLEXCOUNT */ - Long lexCount(Range range); + Long lexCount(Range range); /** * Returns the score of the given element. Returns null if the element is not contained by the set. diff --git a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java index 4b5a67cd4..a290028f4 100644 --- a/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java @@ -44,6 +44,7 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; +import org.springframework.data.domain.Range; import org.springframework.data.domain.Range.Bound; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; @@ -59,7 +60,6 @@ import org.springframework.data.redis.connection.RedisStreamCommands.XClaimOptio import org.springframework.data.redis.connection.RedisStringCommands.BitOperation; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs; import org.springframework.data.redis.connection.SortParameters.Order; import org.springframework.data.redis.connection.StringRedisConnection.StringTuple; @@ -1938,10 +1938,10 @@ public abstract class AbstractConnectionIntegrationTests { actual.add(connection.zAdd("myzset", 0, "g")); actual.add(connection.zLexCount("myzset", Range.unbounded())); - actual.add(connection.zLexCount("myzset", Range.range().lt("c"))); - actual.add(connection.zLexCount("myzset", Range.range().lte("c"))); - actual.add(connection.zLexCount("myzset", Range.range().gte("aaa").lt("g"))); - actual.add(connection.zLexCount("myzset", Range.range().gte("e"))); + actual.add(connection.zLexCount("myzset", Range.leftUnbounded(Bound.exclusive("c")))); + actual.add(connection.zLexCount("myzset", Range.leftUnbounded(Bound.inclusive("c")))); + actual.add(connection.zLexCount("myzset", Range.rightOpen("aaa", "g"))); + actual.add(connection.zLexCount("myzset", Range.rightUnbounded(Bound.inclusive("e")))); List results = getResults(); @@ -2300,7 +2300,7 @@ public abstract class AbstractConnectionIntegrationTests { actual.add(connection.zAdd("myset", 0, "zip")); actual.add(connection.zAdd("myset", 0, "ALPHA")); actual.add(connection.zAdd("myset", 0, "alpha")); - actual.add(connection.zRemRangeByLex("myset", Range.range().gte("alpha").lte("omega"))); + actual.add(connection.zRemRangeByLex("myset", Range.closed("alpha", "omega"))); actual.add(connection.zRange("myset", 0L, -1L)); verifyResults(Arrays.asList(true, true, true, true, true, true, true, true, true, true, 6L, @@ -2815,14 +2815,15 @@ public abstract class AbstractConnectionIntegrationTests { actual.add(connection.zAdd("myzset", 0, "f")); actual.add(connection.zAdd("myzset", 0, "g")); - actual.add(connection.zRangeByLex("myzset", Range.range().lte("c"))); - actual.add(connection.zRangeByLex("myzset", Range.range().lt("c"))); - actual.add(connection.zRangeByLex("myzset", Range.range().gte("aaa").lt("g"))); - actual.add(connection.zRangeByLex("myzset", Range.range().gte("e"))); + actual.add(connection.zRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")))); + actual.add(connection.zRangeByLex("myzset", Range.leftUnbounded(Bound.exclusive("c")))); + actual.add(connection.zRangeByLex("myzset", Range.rightOpen("aaa", "g"))); + actual.add(connection.zRangeByLex("myzset", Range.rightUnbounded(Bound.inclusive("e")))); - actual.add(connection.zRangeByLex("myzset", Range.range().lte("c"), Limit.unlimited())); - actual.add(connection.zRangeByLex("myzset", Range.range().lte("c"), Limit.limit().count(1))); - actual.add(connection.zRangeByLex("myzset", Range.range().lte("c"), Limit.limit().count(1).offset(1))); + actual.add(connection.zRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")), Limit.unlimited())); + actual.add(connection.zRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")), Limit.limit().count(1))); + actual.add( + connection.zRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")), Limit.limit().count(1).offset(1))); List results = getResults(); @@ -2847,14 +2848,15 @@ public abstract class AbstractConnectionIntegrationTests { actual.add(connection.zAdd("myzset", 0, "f")); actual.add(connection.zAdd("myzset", 0, "g")); - actual.add(connection.zRevRangeByLex("myzset", Range.range().lte("c"))); - actual.add(connection.zRevRangeByLex("myzset", Range.range().lt("c"))); - actual.add(connection.zRevRangeByLex("myzset", Range.range().gte("aaa").lt("g"))); - actual.add(connection.zRevRangeByLex("myzset", Range.range().gte("e"))); + actual.add(connection.zRevRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")))); + actual.add(connection.zRevRangeByLex("myzset", Range.leftUnbounded(Bound.exclusive("c")))); + actual.add(connection.zRevRangeByLex("myzset", Range.rightOpen("aaa", "g"))); + actual.add(connection.zRevRangeByLex("myzset", Range.rightUnbounded(Bound.inclusive("e")))); - actual.add(connection.zRevRangeByLex("myzset", Range.range().lte("c"), Limit.unlimited())); - actual.add(connection.zRevRangeByLex("myzset", Range.range().lte("d"), Limit.limit().count(2))); - actual.add(connection.zRevRangeByLex("myzset", Range.range().lte("d"), Limit.limit().count(2).offset(1))); + actual.add(connection.zRevRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("c")), Limit.unlimited())); + actual.add(connection.zRevRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("d")), Limit.limit().count(2))); + actual.add(connection.zRevRangeByLex("myzset", Range.leftUnbounded(Bound.inclusive("d")), + Limit.limit().count(2).offset(1))); List results = getResults(); diff --git a/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java b/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java index 0036902e8..40ed0190c 100644 --- a/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java +++ b/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java @@ -1000,70 +1000,72 @@ class RedisConnectionUnitTests { } @Override - public Set zRangeByLex(byte[] key, Range range) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRangeByLex(key, range); } @Override - public Set zRangeByLex(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByLex(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return delegate.zRangeByLex(key, range, limit); } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range, + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return delegate.zRangeByScoreWithScores(key, range, limit); } @Override - public Set zRevRangeByScore(byte[] key, Range range) { + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRevRangeByScore(key, range); } @Override - public Set zRevRangeByScore(byte[] key, Range range, + public Set zRevRangeByScore(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return delegate.zRevRangeByScore(key, range, limit); } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range, + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { return delegate.zRevRangeByScoreWithScores(key, range, limit); } @Override - public Long zCount(byte[] key, Range range) { + public Long zCount(byte[] key, org.springframework.data.domain.Range range) { return delegate.zCount(key, range); } @Override - public Long zRemRangeByScore(byte[] key, Range range) { + public Long zRemRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRemRangeByScore(key, range); } @Override - public Long zRemRangeByLex(byte[] key, Range range) { + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRemRangeByLex(key, range); } @Override - public Set zRangeByScore(byte[] key, Range range) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRangeByScore(key, range); } @Override - public Set zRangeByScore(byte[] key, Range range, org.springframework.data.redis.connection.Limit limit) { + public Set zRangeByScore(byte[] key, org.springframework.data.domain.Range range, + org.springframework.data.redis.connection.Limit limit) { return delegate.zRangeByScore(key, range, limit); } @Override - public Set zRangeByScoreWithScores(byte[] key, Range range) { + public Set zRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRangeByScoreWithScores(key, range); } @Override - public Set zRevRangeByScoreWithScores(byte[] key, Range range) { + public Set zRevRangeByScoreWithScores(byte[] key, org.springframework.data.domain.Range range) { return delegate.zRevRangeByScoreWithScores(key, range); } diff --git a/src/test/java/org/springframework/data/redis/connection/jedis/JedisClusterConnectionTests.java b/src/test/java/org/springframework/data/redis/connection/jedis/JedisClusterConnectionTests.java index 7a4c82400..b5f71b93e 100644 --- a/src/test/java/org/springframework/data/redis/connection/jedis/JedisClusterConnectionTests.java +++ b/src/test/java/org/springframework/data/redis/connection/jedis/JedisClusterConnectionTests.java @@ -2342,23 +2342,23 @@ public class JedisClusterConnectionTests implements ClusterConnectionTests { nativeConnection.zadd(KEY_1, 0, "f"); nativeConnection.zadd(KEY_1, 0, "g"); - Set values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lte("c")); + Set values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lte("c").toRange()); assertThat(values).contains(JedisConverters.toBytes("a"), JedisConverters.toBytes("b"), JedisConverters.toBytes("c")); assertThat(values).doesNotContain(JedisConverters.toBytes("d"), JedisConverters.toBytes("e"), JedisConverters.toBytes("f"), JedisConverters.toBytes("g")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lt("c")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lt("c").toRange()); assertThat(values).contains(JedisConverters.toBytes("a"), JedisConverters.toBytes("b")); assertThat(values).doesNotContain(JedisConverters.toBytes("c")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g").toRange()); assertThat(values).contains(JedisConverters.toBytes("b"), JedisConverters.toBytes("c"), JedisConverters.toBytes("d"), JedisConverters.toBytes("e"), JedisConverters.toBytes("f")); assertThat(values).doesNotContain(JedisConverters.toBytes("a"), JedisConverters.toBytes("g")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("e")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("e").toRange()); assertThat(values).contains(JedisConverters.toBytes("e"), JedisConverters.toBytes("f"), JedisConverters.toBytes("g")); assertThat(values).doesNotContain(JedisConverters.toBytes("a"), JedisConverters.toBytes("b"), @@ -2376,23 +2376,24 @@ public class JedisClusterConnectionTests implements ClusterConnectionTests { nativeConnection.zadd(KEY_1, 0, "f"); nativeConnection.zadd(KEY_1, 0, "g"); - Set values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("c")); + Set values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("c").toRange()); assertThat(values).containsExactly(JedisConverters.toBytes("c"), JedisConverters.toBytes("b"), JedisConverters.toBytes("a")); assertThat(values).doesNotContain(JedisConverters.toBytes("d"), JedisConverters.toBytes("e"), JedisConverters.toBytes("f"), JedisConverters.toBytes("g")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lt("c")); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lt("c").toRange()); assertThat(values).containsExactly(JedisConverters.toBytes("b"), JedisConverters.toBytes("a")); assertThat(values).doesNotContain(JedisConverters.toBytes("c")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g")); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g").toRange()); assertThat(values).containsExactly(JedisConverters.toBytes("f"), JedisConverters.toBytes("e"), JedisConverters.toBytes("d"), JedisConverters.toBytes("c"), JedisConverters.toBytes("b")); assertThat(values).doesNotContain(JedisConverters.toBytes("a"), JedisConverters.toBytes("g")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("d"), Limit.limit().count(2).offset(1)); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("d").toRange(), + Limit.limit().count(2).offset(1)); assertThat(values).hasSize(2).containsExactly(JedisConverters.toBytes("c"), JedisConverters.toBytes("b")); assertThat(values).doesNotContain(JedisConverters.toBytes("a"), JedisConverters.toBytes("d"), diff --git a/src/test/java/org/springframework/data/redis/connection/jedis/JedisConvertersUnitTests.java b/src/test/java/org/springframework/data/redis/connection/jedis/JedisConvertersUnitTests.java index 7bdd6b1b2..9e6c84578 100644 --- a/src/test/java/org/springframework/data/redis/connection/jedis/JedisConvertersUnitTests.java +++ b/src/test/java/org/springframework/data/redis/connection/jedis/JedisConvertersUnitTests.java @@ -30,14 +30,17 @@ import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.RedisServer; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; import org.springframework.data.redis.core.types.Expiration; import org.springframework.data.redis.core.types.RedisClientInfo; /** + * Unit tests for {@link JedisConverters}. + * * @author Christoph Strobl + * @author Mark Paluch */ class JedisConvertersUnitTests { @@ -113,46 +116,38 @@ class JedisConvertersUnitTests { byte[] defaultValue = "tyrion".getBytes(); - assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.unbounded().getMax(), defaultValue)) + assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.Bound.unbounded(), defaultValue)) .isEqualTo(defaultValue); } @Test // DATAREDIS-378 void boundaryToBytesForZRangeByLexShouldReturnValueCorrectlyWhenBoundaryIsIncluing() { - assertThat( - JedisConverters.boundaryToBytesForZRangeByLex(Range.range().gte(JedisConverters.toBytes("a")).getMin(), null)) - .isEqualTo(JedisConverters.toBytes("[a")); + assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.Bound.inclusive(JedisConverters.toBytes("a")), null)) + .isEqualTo(JedisConverters.toBytes("[a")); } @Test // DATAREDIS-378 void boundaryToBytesForZRangeByLexShouldReturnValueCorrectlyWhenBoundaryIsExcluding() { - assertThat( - JedisConverters.boundaryToBytesForZRangeByLex(Range.range().gt(JedisConverters.toBytes("a")).getMin(), null)) - .isEqualTo(JedisConverters.toBytes("(a")); + assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.Bound.exclusive(JedisConverters.toBytes("a")), null)) + .isEqualTo(JedisConverters.toBytes("(a")); } @Test // DATAREDIS-378 void boundaryToBytesForZRangeByLexShouldReturnValueCorrectlyWhenBoundaryIsAString() { - assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.range().gt("a").getMin(), null)) + assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.Bound.exclusive(JedisConverters.toBytes("a")), null)) .isEqualTo(JedisConverters.toBytes("(a")); } @Test // DATAREDIS-378 void boundaryToBytesForZRangeByLexShouldReturnValueCorrectlyWhenBoundaryIsANumber() { - assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.range().gt(1L).getMin(), null)) + assertThat(JedisConverters.boundaryToBytesForZRangeByLex(Range.Bound.exclusive(JedisConverters.toBytes("1")), null)) .isEqualTo(JedisConverters.toBytes("(1")); } - @Test // DATAREDIS-378 - void boundaryToBytesForZRangeByLexShouldThrowExceptionWhenBoundaryHoldsUnknownType() { - assertThatIllegalArgumentException() - .isThrownBy(() -> JedisConverters.boundaryToBytesForZRangeByLex(Range.range().gt(new Date()).getMin(), null)); - } - @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldReturnDefaultValueWhenBoundaryIsNull() { @@ -166,42 +161,42 @@ class JedisConvertersUnitTests { byte[] defaultValue = "tyrion".getBytes(); - assertThat(JedisConverters.boundaryToBytesForZRange(Range.unbounded().getMax(), defaultValue)) - .isEqualTo(defaultValue); + assertThat(JedisConverters.boundaryToBytesForZRange(Range.Bound.unbounded(), defaultValue)).isEqualTo(defaultValue); } @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldReturnValueCorrectlyWhenBoundaryIsIncluing() { - assertThat(JedisConverters.boundaryToBytesForZRange(Range.range().gte(JedisConverters.toBytes("a")).getMin(), null)) + assertThat(JedisConverters.boundaryToBytesForZRange(Range.Bound.inclusive(JedisConverters.toBytes("a")), null)) .isEqualTo(JedisConverters.toBytes("a")); } @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldReturnValueCorrectlyWhenBoundaryIsExcluding() { - assertThat(JedisConverters.boundaryToBytesForZRange(Range.range().gt(JedisConverters.toBytes("a")).getMin(), null)) + assertThat(JedisConverters.boundaryToBytesForZRange(Range.Bound.exclusive(JedisConverters.toBytes("a")), null)) .isEqualTo(JedisConverters.toBytes("(a")); } @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldReturnValueCorrectlyWhenBoundaryIsAString() { - assertThat(JedisConverters.boundaryToBytesForZRange(Range.range().gt("a").getMin(), null)) + assertThat(JedisConverters.boundaryToBytesForZRange(Range.Bound.exclusive("a"), null)) .isEqualTo(JedisConverters.toBytes("(a")); } @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldReturnValueCorrectlyWhenBoundaryIsANumber() { - assertThat(JedisConverters.boundaryToBytesForZRange(Range.range().gt(1L).getMin(), null)) - .isEqualTo(JedisConverters.toBytes("(1")); + assertThat( + JedisConverters.boundaryToBytesForZRange(org.springframework.data.domain.Range.Bound.exclusive(1L), null)) + .isEqualTo(JedisConverters.toBytes("(1")); } @Test // DATAREDIS-352 void boundaryToBytesForZRangeByShouldThrowExceptionWhenBoundaryHoldsUnknownType() { assertThatIllegalArgumentException() - .isThrownBy(() -> JedisConverters.boundaryToBytesForZRange(Range.range().gt(new Date()).getMin(), null)); + .isThrownBy(() -> JedisConverters.boundaryToBytesForZRange(Range.Bound.exclusive(new Date()), null)); } @Test // DATAREDIS-316, DATAREDIS-749 diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceClusterConnectionTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceClusterConnectionTests.java index 3a46192be..bf9f09adc 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceClusterConnectionTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceClusterConnectionTests.java @@ -2382,23 +2382,23 @@ public class LettuceClusterConnectionTests implements ClusterConnectionTests { nativeConnection.zadd(KEY_1, 0, "f"); nativeConnection.zadd(KEY_1, 0, "g"); - Set values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lte("c")); + Set values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lte("c").toRange()); assertThat(values).contains(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("b"), LettuceConverters.toBytes("c")); assertThat(values).doesNotContain(LettuceConverters.toBytes("d"), LettuceConverters.toBytes("e"), LettuceConverters.toBytes("f"), LettuceConverters.toBytes("g")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lt("c")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().lt("c").toRange()); assertThat(values).contains(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("b")); assertThat(values).doesNotContain(LettuceConverters.toBytes("c")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g").toRange()); assertThat(values).contains(LettuceConverters.toBytes("b"), LettuceConverters.toBytes("c"), LettuceConverters.toBytes("d"), LettuceConverters.toBytes("e"), LettuceConverters.toBytes("f")); assertThat(values).doesNotContain(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("g")); - values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("e")); + values = clusterConnection.zRangeByLex(KEY_1_BYTES, Range.range().gte("e").toRange()); assertThat(values).contains(LettuceConverters.toBytes("e"), LettuceConverters.toBytes("f"), LettuceConverters.toBytes("g")); assertThat(values).doesNotContain(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("b"), @@ -2416,23 +2416,24 @@ public class LettuceClusterConnectionTests implements ClusterConnectionTests { nativeConnection.zadd(KEY_1, 0, "f"); nativeConnection.zadd(KEY_1, 0, "g"); - Set values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("c")); + Set values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("c").toRange()); assertThat(values).containsExactly(LettuceConverters.toBytes("c"), LettuceConverters.toBytes("b"), LettuceConverters.toBytes("a")); assertThat(values).doesNotContain(LettuceConverters.toBytes("d"), LettuceConverters.toBytes("e"), LettuceConverters.toBytes("f"), LettuceConverters.toBytes("g")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lt("c")); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lt("c").toRange()); assertThat(values).containsExactly(LettuceConverters.toBytes("b"), LettuceConverters.toBytes("a")); assertThat(values).doesNotContain(LettuceConverters.toBytes("c")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g")); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().gte("aaa").lt("g").toRange()); assertThat(values).containsExactly(LettuceConverters.toBytes("f"), LettuceConverters.toBytes("e"), LettuceConverters.toBytes("d"), LettuceConverters.toBytes("c"), LettuceConverters.toBytes("b")); assertThat(values).doesNotContain(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("g")); - values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("d"), Limit.limit().count(2).offset(1)); + values = clusterConnection.zRevRangeByLex(KEY_1_BYTES, Range.range().lte("d").toRange(), + Limit.limit().count(2).offset(1)); assertThat(values).hasSize(2).containsExactly(LettuceConverters.toBytes("c"), LettuceConverters.toBytes("b")); assertThat(values).doesNotContain(LettuceConverters.toBytes("a"), LettuceConverters.toBytes("d"), diff --git a/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsIntegrationTests.java b/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsIntegrationTests.java index ae9347c3b..221afbc74 100644 --- a/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsIntegrationTests.java @@ -29,6 +29,7 @@ import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; +import org.springframework.data.domain.Range; import org.springframework.data.redis.DoubleAsStringObjectFactory; import org.springframework.data.redis.DoubleObjectFactory; import org.springframework.data.redis.LongAsStringObjectFactory; @@ -112,7 +113,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value2, 0); zSetOps.add(key, value3, 0); - assertThat(zSetOps.lexCount(key, RedisZSetCommands.Range.unbounded())).isEqualTo(3); + assertThat(zSetOps.lexCount(key, Range.unbounded())).isEqualTo(3); } @ParameterizedRedisTest // DATAREDIS-729 @@ -130,7 +131,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value2, 0); zSetOps.add(key, value3, 0); - assertThat(zSetOps.lexCount(key, RedisZSetCommands.Range.range().gt(value1))).isEqualTo(2); + assertThat(zSetOps.lexCount(key, Range.rightUnbounded(Range.Bound.exclusive(value1.toString())))).isEqualTo(2); } @ParameterizedRedisTest // GH-2007 @@ -310,7 +311,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value1, 1.9); zSetOps.add(key, value2, 3.7); zSetOps.add(key, value3, 5.8); - Set tuples = zSetOps.rangeByLex(key, RedisZSetCommands.Range.unbounded()); + Set tuples = zSetOps.rangeByLex(key, Range.unbounded()); assertThat(tuples).hasSize(3).contains(value1); } @@ -329,7 +330,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value1, 1.9); zSetOps.add(key, value2, 3.7); zSetOps.add(key, value3, 5.8); - Set tuples = zSetOps.rangeByLex(key, RedisZSetCommands.Range.range().gt(value1).lt(value3)); + Set tuples = zSetOps.rangeByLex(key, Range.open(value1.toString(), value3.toString())); assertThat(tuples).hasSize(1).contains(value2); } @@ -348,8 +349,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value1, 1.9); zSetOps.add(key, value2, 3.7); zSetOps.add(key, value3, 5.8); - Set tuples = zSetOps.rangeByLex(key, RedisZSetCommands.Range.unbounded(), - Limit.limit().count(2).offset(1)); + Set tuples = zSetOps.rangeByLex(key, Range.unbounded(), Limit.limit().count(2).offset(1)); assertThat(tuples).hasSize(2).containsSequence(value2, value3); } @@ -368,8 +368,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value1, 1.9); zSetOps.add(key, value2, 3.7); zSetOps.add(key, value3, 5.8); - Set tuples = zSetOps.reverseRangeByLex(key, RedisZSetCommands.Range.unbounded(), - Limit.limit().count(2).offset(1)); + Set tuples = zSetOps.reverseRangeByLex(key, Range.unbounded(), Limit.limit().count(2).offset(1)); assertThat(tuples).hasSize(2).containsSequence(value2, value1); } @@ -388,7 +387,7 @@ public class DefaultZSetOperationsIntegrationTests { zSetOps.add(key, value1, 1.9); zSetOps.add(key, value2, 3.7); zSetOps.add(key, value3, 5.8); - Set tuples = zSetOps.rangeByLex(key, RedisZSetCommands.Range.range().gte(value1), + Set tuples = zSetOps.rangeByLex(key, Range.rightUnbounded(Range.Bound.inclusive(value1.toString())), Limit.limit().count(1).offset(1)); assertThat(tuples).hasSize(1).startsWith(value2); diff --git a/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsUnitTests.java b/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsUnitTests.java index e0a224ad6..855a26922 100644 --- a/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsUnitTests.java +++ b/src/test/java/org/springframework/data/redis/core/DefaultZSetOperationsUnitTests.java @@ -22,7 +22,8 @@ import java.util.Set; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import org.springframework.data.redis.connection.RedisZSetCommands.Range; + +import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs; import org.springframework.data.redis.core.ZSetOperations.TypedTuple; @@ -46,10 +47,10 @@ class DefaultZSetOperationsUnitTests { @Test // GH-1816 void delegatesRemoveRangeByLex() { - Range range = Range.range().gte("alpha").lte("omega"); + Range range = Range.closed("alpha", "omega"); zSetOperations.removeRangeByLex("key", range); - template.verify().zRemRangeByLex(eq(template.serializeKey("key")), eq(range)); + template.verify().zRemRangeByLex(eq(template.serializeKey("key")), any(Range.class)); } @Test // GH-1794 diff --git a/src/test/java/org/springframework/data/redis/support/collections/AbstractRedisZSetTestIntegration.java b/src/test/java/org/springframework/data/redis/support/collections/AbstractRedisZSetTestIntegration.java index 15bcc2ac5..295aa27bb 100644 --- a/src/test/java/org/springframework/data/redis/support/collections/AbstractRedisZSetTestIntegration.java +++ b/src/test/java/org/springframework/data/redis/support/collections/AbstractRedisZSetTestIntegration.java @@ -29,13 +29,13 @@ import java.util.concurrent.TimeUnit; import org.assertj.core.data.Offset; import org.junit.jupiter.api.BeforeEach; +import org.springframework.data.domain.Range; import org.springframework.data.redis.DoubleAsStringObjectFactory; import org.springframework.data.redis.DoubleObjectFactory; import org.springframework.data.redis.LongAsStringObjectFactory; import org.springframework.data.redis.LongObjectFactory; import org.springframework.data.redis.ObjectFactory; import org.springframework.data.redis.connection.Limit; -import org.springframework.data.redis.connection.RedisZSetCommands; import org.springframework.data.redis.core.BoundZSetOperations; import org.springframework.data.redis.core.Cursor; import org.springframework.data.redis.core.DefaultTypedTuple; @@ -260,7 +260,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t2, 1); zSet.add(t3, 1); - assertThat(zSet.lexCount(RedisZSetCommands.Range.unbounded())).isEqualTo(Long.valueOf(3)); + assertThat(zSet.lexCount(Range.unbounded())).isEqualTo(Long.valueOf(3)); } @ParameterizedRedisTest // DATAREDIS-729 @@ -277,7 +277,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t2, 1); zSet.add(t3, 1); - assertThat(zSet.lexCount(RedisZSetCommands.Range.range().gt(t1))).isEqualTo(Long.valueOf(2)); + assertThat(zSet.lexCount(Range.rightUnbounded(Range.Bound.exclusive(t1.toString())))).isEqualTo(Long.valueOf(2)); } @ParameterizedRedisTest @@ -401,7 +401,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t1, 1); zSet.add(t2, 2); zSet.add(t3, 3); - Set tuples = zSet.rangeByLex(RedisZSetCommands.Range.unbounded()); + Set tuples = zSet.rangeByLex(Range.unbounded()); assertThat(tuples).hasSize(3); T tuple = tuples.iterator().next(); @@ -421,7 +421,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t1, 1); zSet.add(t2, 2); zSet.add(t3, 3); - Set tuples = zSet.rangeByLex(RedisZSetCommands.Range.range().gt(t1).lt(t3)); + Set tuples = zSet.rangeByLex(Range.open(t1.toString(), t3.toString())); assertThat(tuples).hasSize(1); T tuple = tuples.iterator().next(); @@ -441,8 +441,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t1, 1); zSet.add(t2, 2); zSet.add(t3, 3); - Set tuples = zSet.rangeByLex(RedisZSetCommands.Range.unbounded(), - Limit.limit().count(1).offset(1)); + Set tuples = zSet.rangeByLex(Range.unbounded(), Limit.limit().count(1).offset(1)); assertThat(tuples).hasSize(1); T tuple = tuples.iterator().next(); @@ -452,8 +451,8 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC @ParameterizedRedisTest // DATAREDIS-407 void testRangeByLexBoundedWithLimit() { - assumeThat(factory).isOfAnyClassIn(DoubleObjectFactory.class, - LongAsStringObjectFactory.class, LongObjectFactory.class); + assumeThat(factory).isOfAnyClassIn(DoubleObjectFactory.class, LongAsStringObjectFactory.class, + LongObjectFactory.class); T t1 = getT(); T t2 = getT(); @@ -462,7 +461,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t1, 1); zSet.add(t2, 2); zSet.add(t3, 3); - Set tuples = zSet.rangeByLex(RedisZSetCommands.Range.range().gte(t1), + Set tuples = zSet.rangeByLex(Range.rightUnbounded(Range.Bound.inclusive(t1.toString())), Limit.limit().count(2).offset(1)); assertThat(tuples).hasSize(2).containsSequence(t2, t3); @@ -481,7 +480,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC zSet.add(t1, 1); zSet.add(t2, 2); zSet.add(t3, 3); - Set tuples = zSet.reverseRangeByLex(RedisZSetCommands.Range.range().gte(t1), + Set tuples = zSet.reverseRangeByLex(Range.rightUnbounded(Range.Bound.inclusive(t1.toString())), Limit.limit().count(2).offset(1)); assertThat(tuples).hasSize(2).containsSequence(t2, t1); @@ -863,7 +862,7 @@ public abstract class AbstractRedisZSetTestIntegration extends AbstractRedisC @EnabledOnCommand("ZRANDMEMBER") void randMemberReturnsSomething() { - Object[] valuesArray = new Object[]{getT(), getT(), getT()}; + Object[] valuesArray = new Object[] { getT(), getT(), getT() }; collection.addAll((List) Arrays.asList(valuesArray));