diff --git a/pom.xml b/pom.xml index 4bd510786b..8269ef5500 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ org.springframework.data spring-data-redis - 3.0.0-SNAPSHOT + 3.0.0-GH-2288-SNAPSHOT Spring Data Redis Spring Data module for Redis diff --git a/src/main/asciidoc/upgrading.adoc b/src/main/asciidoc/upgrading.adoc index fbbabef03e..654e12564d 100644 --- a/src/main/asciidoc/upgrading.adoc +++ b/src/main/asciidoc/upgrading.adoc @@ -1,7 +1,10 @@ [[upgrading]] = Upgrading -The following section provides information about changes that are likely to have an effect on the application and might even prevent it from compiling. +This section contains details about migration steps, deprecations, and removals. + +[[upgrading.2-to-3]] +== Upgrading from 2.x to 3.x === Re-/moved Types @@ -14,12 +17,18 @@ The following section provides information about changes that are likely to have |o.s.d.redis.VersionParser |- +|o.s.d.redis.connection.RedisZSetCommands.Aggregate +|o.s.d.redis.connection.zset.Aggregate + |o.s.d.redis.connection.RedisZSetCommands.Tuple |o.s.d.redis.connection.zset.Tuple |o.s.d.redis.connection.RedisZSetCommands.Weights |o.s.d.redis.connection.zset.Weights +|o.s.d.redis.connection.RedisZSetCommands.Range +|o.s.d.domain.Range + |o.s.d.redis.connection.RedisZSetCommands.Limit |o.s.d.redis.connection.Limit.java @@ -228,16 +237,16 @@ The following section provides information about changes that are likely to have |=== -== Lettuce +=== Lettuce -=== Lettuce Pool +==== Lettuce Pool `LettucePool` and its implementation `DefaultLettucePool` have been removed without replacement. Please refer to the https://lettuce.io/core/release/reference/index.html#_connection_pooling[driver documentation] for driver native pooling capabilities. Methods accepting pooling parameters have been updated. This effects methods on `LettuceConnectionFactory` and `LettuceConnection`. -=== Lettuce Authentication +==== Lettuce Authentication `AuthenticatingRedisClient` has been removed without replacement. Please refer to the https://lettuce.io/core/release/reference/index.html#basic.redisuri[driver documentation] for `RedisURI` to set authentication data. 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 69d608c3ed..25cbb33df2 100644 --- a/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java @@ -48,6 +48,7 @@ import org.springframework.data.redis.connection.stream.StreamOffset; import org.springframework.data.redis.connection.stream.StreamReadOptions; import org.springframework.data.redis.connection.stream.StringRecord; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; @@ -990,7 +991,7 @@ public Long zCount(byte[] key, double min, double max) { } @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 Set zRangeByScore(byte[] key, double min, double max, long offset } @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 Set zRangeByScoreWithScores(byte[] key, double min, double max, lo } @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 Set zRevRangeByScore(byte[] key, double min, double max, long off } @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 Set zRevRangeByScore(byte[] key, double min, double max) { } @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 Set zRevRangeByScoreWithScores(byte[] key, double min, double max, } @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 Long zRemRange(byte[] key, long start, long end) { } @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 Long zRemRangeByScore(byte[] key, double min, double max) { } @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 Long zUnionStore(byte[] destKey, byte[]... sets) { } @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 @@ private byte[] serialize(String data) { 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 Long zCount(String key, double min, double max) { } @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 Long zRemRange(String key, long start, long end) { } @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 Set zRangeByLex(byte[] key) { } @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 801d4b19f4..cc7d4288e5 100644 --- a/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java @@ -40,6 +40,7 @@ import org.springframework.data.redis.connection.stream.StreamInfo.XInfoStream; import org.springframework.data.redis.connection.stream.StreamOffset; import org.springframework.data.redis.connection.stream.StreamReadOptions; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.Cursor; @@ -967,7 +968,7 @@ default Long zCount(byte[] key, double min, double max) { /** @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 @@ default Tuple bZPopMax(byte[] key, long timeout, TimeUnit unit) { /** @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 @@ default Set zRangeWithScores(byte[] key, long start, long end) { /** @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 @@ default Set zRevRangeWithScores(byte[] key, long start, long end) { /** @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 @@ default Long zRemRange(byte[] key, long start, long end) { /** @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/ReactiveZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/ReactiveZSetCommands.java index 0b7de03e13..bc0607d706 100644 --- a/src/main/java/org/springframework/data/redis/connection/ReactiveZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/ReactiveZSetCommands.java @@ -33,7 +33,7 @@ import org.reactivestreams.Publisher; import org.springframework.data.domain.Range; import org.springframework.data.domain.Sort.Direction; -import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; 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 a85be1de79..3ca6e47b43 100644 --- a/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java @@ -20,6 +20,7 @@ import java.util.Set; import java.util.concurrent.TimeUnit; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.Cursor; @@ -41,32 +42,29 @@ public interface RedisZSetCommands { /** - * Sort aggregation operations. - */ - enum Aggregate { - SUM, MIN, MAX; - } - - /** - * {@link Range} defines {@literal min} and {@literal max} values to retrieve from a {@literal ZSET}. + * {@link org.springframework.data.domain.Range} defines {@literal min} and {@literal max} values to retrieve from a + * {@literal ZSET}. * * @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; @Nullable Boundary max; /** - * @return new {@link Range} + * @return new {@link org.springframework.data.domain.Range} */ public static Range range() { return new Range(); } /** - * @return new {@link Range} with {@literal min} and {@literal max} set to {@link Boundary#infinite()}. + * @return new {@link org.springframework.data.domain.Range} with {@literal min} and {@literal max} set to + * {@link Boundary#infinite()}. */ public static Range unbounded() { @@ -172,6 +170,30 @@ public boolean isIncluding() { } } + /** + * 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 +554,7 @@ default Long zAdd(byte[] key, Set tuples) { */ @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 +568,7 @@ default Set zRangeByScore(byte[] key, double min, double max) { * @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 +584,7 @@ default Set zRangeByScoreWithScores(byte[] key, Range range) { */ @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 +602,7 @@ default Set zRangeByScoreWithScores(byte[] key, double min, double max) { */ @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 +622,7 @@ default Set zRangeByScore(byte[] key, double min, double max, long offse */ @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 +640,8 @@ default Set zRangeByScoreWithScores(byte[] key, double min, double max, l * @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 +681,7 @@ default Set zRangeByScoreWithScores(byte[] key, double min, double max, l */ @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 +696,7 @@ default Set zRevRangeByScore(byte[] key, double min, double max) { * @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 +713,7 @@ default Set zRevRangeByScore(byte[] key, Range range) { */ @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 +731,7 @@ default Set zRevRangeByScoreWithScores(byte[] key, double min, double max @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 +747,8 @@ default Set zRevRangeByScore(byte[] key, double min, double max, long of * @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 +765,7 @@ default Set zRevRangeByScore(byte[] key, double min, double max, long of @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 +781,7 @@ default Set zRevRangeByScoreWithScores(byte[] key, double min, double max * @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 +797,8 @@ default Set zRevRangeByScoreWithScores(byte[] key, Range range) { * @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 +811,7 @@ default Set zRevRangeByScoreWithScores(byte[] key, Range range) { */ @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 +824,7 @@ default Long zCount(byte[] key, double min, double max) { * @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 +837,7 @@ default Long zCount(byte[] key, double min, double max) { * @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}. @@ -934,7 +959,7 @@ default Long zCount(byte[] key, double min, double max) { Long zRemRange(byte[] key, long start, long end); /** - * Remove all elements between the lexicographical {@link Range}. + * Remove all elements between the lexicographical {@link org.springframework.data.domain.Range}. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -942,7 +967,7 @@ default Long zCount(byte[] key, double min, double max) { * @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 +980,7 @@ default Long zCount(byte[] key, double min, double max) { */ @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 +993,7 @@ default Long zRemRangeByScore(byte[] key, double min, double max) { * @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 +1228,12 @@ default Long zUnionStore(byte[] destKey, Aggregate aggregate, int[] weights, byt * @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 +1246,7 @@ default Set zRangeByScore(byte[] key, String min, String max) { * @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 +1278,8 @@ default Set zRangeByScore(byte[] key, Range range) { * @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,11 +1291,12 @@ default Set zRangeByScore(byte[] key, Range range) { */ @Nullable default Set zRangeByLex(byte[] key) { - return zRangeByLex(key, Range.unbounded()); + return zRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** - * Get all the elements in {@link Range} from the sorted set at {@literal key} in lexicographical ordering. + * Get all the elements in {@link org.springframework.data.domain.Range} from the sorted set at {@literal key} in + * lexicographical ordering. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -1276,13 +1305,13 @@ default Set zRangeByLex(byte[] key) { * @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()); } /** - * Get all the elements in {@link Range} from the sorted set at {@literal key} in lexicographical ordering. Result is - * limited via {@link Limit}. + * Get all the elements in {@link org.springframework.data.domain.Range} from the sorted set at {@literal key} in + * lexicographical ordering. Result is limited via {@link Limit}. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -1292,7 +1321,8 @@ default Set zRangeByLex(byte[] key, Range range) { * @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,11 +1334,12 @@ default Set zRangeByLex(byte[] key, Range range) { */ @Nullable default Set zRevRangeByLex(byte[] key) { - return zRevRangeByLex(key, Range.unbounded()); + return zRevRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** - * Get all the elements in {@link Range} from the sorted set at {@literal key} in reversed lexicographical ordering. + * Get all the elements in {@link org.springframework.data.domain.Range} from the sorted set at {@literal key} in + * reversed lexicographical ordering. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -1317,13 +1348,13 @@ default Set zRevRangeByLex(byte[] key) { * @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()); } /** - * Get all the elements in {@link Range} from the sorted set at {@literal key} in reversed lexicographical ordering. - * Result is limited via {@link Limit}. + * Get all the elements in {@link org.springframework.data.domain.Range} from the sorted set at {@literal key} in + * reversed lexicographical ordering. Result is limited via {@link Limit}. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. @@ -1333,6 +1364,7 @@ default Set zRevRangeByLex(byte[] key, Range range) { * @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 8a71eed037..6043185e0d 100644 --- a/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java +++ b/src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java @@ -41,6 +41,7 @@ import org.springframework.data.redis.connection.stream.StreamReadOptions; import org.springframework.data.redis.connection.stream.StreamRecords; import org.springframework.data.redis.connection.stream.StringRecord; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.Cursor; @@ -1535,10 +1536,10 @@ default Long lPos(String key, String element) { * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZLEXCOUNT - * @see RedisZSetCommands#zLexCount(byte[], Range) + * @see RedisZSetCommands#zLexCount(byte[], org.springframework.data.domain.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 +1670,7 @@ default Long lPos(String key, String element) { * @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}. @@ -1925,9 +1926,9 @@ default Set zUnionWithScores(Aggregate aggregate, int[] weights, St * @return * @since 1.6 * @see Redis Documentation: ZRANGEBYLEX - * @see RedisZSetCommands#zRangeByLex(byte[], Range) + * @see RedisZSetCommands#zRangeByLex(byte[], org.springframework.data.domain.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 @@ -1939,9 +1940,10 @@ default Set zUnionWithScores(Aggregate aggregate, int[] weights, St * @return * @since 1.6 * @see Redis Documentation: ZRANGEBYLEX - * @see RedisZSetCommands#zRangeByLex(byte[], Range, Limit) + * @see RedisZSetCommands#zRangeByLex(byte[], org.springframework.data.domain.Range, org.springframework.data.redis.connection.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 +1955,7 @@ default Set zUnionWithScores(Aggregate aggregate, int[] weights, St * @see RedisZSetCommands#zRevRangeByLex(byte[]) */ default Set zRevRangeByLex(String key) { - return zRevRangeByLex(key, Range.unbounded()); + return zRevRangeByLex(key, org.springframework.data.domain.Range.unbounded()); } /** @@ -1964,9 +1966,9 @@ default Set zRevRangeByLex(String key) { * @return * @since 2.4 * @see Redis Documentation: ZREVRANGEBYLEX - * @see RedisZSetCommands#zRevRangeByLex(byte[], Range) + * @see RedisZSetCommands#zRevRangeByLex(byte[], org.springframework.data.domain.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()); } @@ -1980,9 +1982,10 @@ default Set zRevRangeByLex(String key, Range range) { * @return * @since 2.4 * @see Redis Documentation: ZREVRANGEBYLEX - * @see RedisZSetCommands#zRevRangeByLex(byte[], Range, Limit) + * @see RedisZSetCommands#zRevRangeByLex(byte[], org.springframework.data.domain.Range, org.springframework.data.redis.connection.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 e4376b14b5..ba69c3e13f 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 @@ -31,6 +31,7 @@ import org.springframework.data.redis.connection.ClusterSlotHashUtil; import org.springframework.data.redis.connection.RedisZSetCommands; import org.springframework.data.redis.connection.convert.SetConverter; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; @@ -205,14 +206,16 @@ public Set zRange(byte[] key, long start, long end) { } @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 +229,16 @@ public Set zRangeByScoreWithScores(byte[] key, Range range, } @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 +252,16 @@ public Set zRevRangeByScore(byte[] key, Range range, org.springframework } @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 +275,15 @@ public Set zRevRangeByScoreWithScores(byte[] key, Range range, } @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 +293,13 @@ public Long zCount(byte[] key, Range range) { } @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 +391,15 @@ public Tuple bZPopMax(byte[] key, long timeout, TimeUnit unit) { } @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 +410,16 @@ public Long zRemRangeByScore(byte[] key, Range 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) { 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 +433,15 @@ public Set zRangeByScore(byte[] key, Range range, org.springframework.da } @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 +455,13 @@ public Set zRangeByLex(byte[] key, Range range, org.springframework.data } @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 +471,15 @@ public Long zRemRangeByLex(byte[] key, Range range) { } @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 8b72d3fd06..429a143d00 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.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 @@ public static BitOP toBitOp(BitOperation bitOp) { } /** - * 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 @@ public static BitOP toBitOp(BitOperation bitOp) { * @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 @@ public static byte[] boundaryToBytesForZRange(@Nullable Boundary boundary, byte[ } /** - * 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 @@ public static SetParams toSetCommandNxXxArgument(SetOption option, SetParams par } } - 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 347089639e..1ea87fbc67 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 @@ -28,6 +28,7 @@ import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.redis.connection.RedisZSetCommands; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; @@ -171,15 +172,17 @@ public Set zRangeWithScores(byte[] key, long start, long end) { } @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 +214,17 @@ public Set zRevRangeWithScores(byte[] key, long start, long end) { } @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 +236,17 @@ public Set zRevRangeByScore(byte[] key, Range range, org.springframework } @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 +268,27 @@ public Long zCount(byte[] key, double min, double max) { } @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 +390,27 @@ public Long zRemRange(byte[] key, long start, long end) { } @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 +616,17 @@ public Set zRangeByScore(byte[] key, String min, String max, long offset } @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 +638,15 @@ public Set zRangeByScore(byte[] key, Range range, org.springframework.da } @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 +657,15 @@ public Set zRangeByLex(byte[] key, Range range, org.springframework.data } @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 f2322f042d..1a9afb12d9 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 @@ -48,7 +48,6 @@ import org.springframework.data.redis.connection.RedisListCommands.Position; import org.springframework.data.redis.connection.RedisNode.NodeType; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; -import org.springframework.data.redis.connection.RedisZSetCommands.Range.Boundary; import org.springframework.data.redis.connection.SortParameters.Order; import org.springframework.data.redis.connection.convert.Converters; import org.springframework.data.redis.connection.convert.StringToRedisClientInfoConverter; @@ -257,19 +256,6 @@ public static List toListOfRedisClientInformation(String client return StringToRedisClientInfoConverter.INSTANCE.convert(clientList.split("\\r?\\n")); } - private static String boundaryToString(Boundary boundary, String inclPrefix, String exclPrefix) { - - String prefix = boundary.isIncluding() ? inclPrefix : exclPrefix; - String value = null; - if (boundary.getValue() instanceof byte[]) { - value = toString((byte[]) boundary.getValue()); - } else { - value = boundary.getValue().toString(); - } - - return prefix + value; - } - /** * Convert a {@link Limit} to a Lettuce {@link io.lettuce.core.Limit}. * @@ -289,81 +275,45 @@ public static io.lettuce.core.Limit toLimit(Limit limit) { * @return * @since 2.0 */ - public static Range toRange(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { - return Range.from(lowerBoundaryOf(range, false), upperBoundaryOf(range, false)); + public static Range toRange(org.springframework.data.domain.Range range) { + return toRange(range, false); } /** - * Convert a {@link org.springframework.data.redis.connection.RedisZSetCommands.Range} to a lettuce {@link Range}. + * Convert a {@link org.springframework.data.domain.Range} to a lettuce {@link Range}. * * @param range * @param convertNumberToBytes * @return * @since 2.2 */ - public static Range toRange(org.springframework.data.redis.connection.RedisZSetCommands.Range range, - boolean convertNumberToBytes) { - return Range.from(lowerBoundaryOf(range, convertNumberToBytes), upperBoundaryOf(range, convertNumberToBytes)); + @SuppressWarnings({ "rawtypes", "unchecked" }) + public static Range toRange(org.springframework.data.domain.Range range, boolean convertNumberToBytes) { + + Range.Boundary upper = RangeConverter.convertBound(range.getUpperBound(), convertNumberToBytes, null, + it -> it.getBytes(StandardCharsets.UTF_8)); + Range.Boundary lower = RangeConverter.convertBound(range.getLowerBound(), convertNumberToBytes, null, + it -> it.getBytes(StandardCharsets.UTF_8)); + + return Range.from(lower, upper); } /** - * Convert a {@link org.springframework.data.redis.connection.RedisZSetCommands.Range} to a lettuce {@link Range} and - * reverse boundaries. + * Convert a {@link org.springframework.data.domain.Range} to a lettuce {@link Range} and reverse boundaries. * * @param range * @return * @since 2.0 */ - public static Range toRevRange(org.springframework.data.redis.connection.RedisZSetCommands.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) { - 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) { - return (Range.Boundary) rangeToBoundaryArgumentConverter(true, convertNumberToBytes).convert(range); - } + @SuppressWarnings({ "rawtypes", "unchecked" }) + public static Range toRevRange(org.springframework.data.domain.Range range) { - private static Converter> rangeToBoundaryArgumentConverter( - boolean upper, boolean convertNumberToBytes) { + Range.Boundary upper = RangeConverter.convertBound(range.getUpperBound(), false, null, + it -> it.getBytes(StandardCharsets.UTF_8)); + Range.Boundary lower = RangeConverter.convertBound(range.getLowerBound(), false, null, + it -> it.getBytes(StandardCharsets.UTF_8)); - return (source) -> { - - Boundary sourceBoundary = upper ? source.getMax() : source.getMin(); - if (sourceBoundary == null || sourceBoundary.getValue() == null) { - return Range.Boundary.unbounded(); - } - - boolean inclusive = sourceBoundary.isIncluding(); - Object value = sourceBoundary.getValue(); - - if (value instanceof Number) { - - if (convertNumberToBytes) { - value = value.toString(); - } else { - return inclusive ? Range.Boundary.including((Number) value) : Range.Boundary.excluding((Number) value); - } - } - - if (value instanceof String) { - - if (!StringUtils.hasText((String) value) || ObjectUtils.nullSafeEquals(value, "+") - || ObjectUtils.nullSafeEquals(value, "-")) { - return Range.Boundary.unbounded(); - } - return inclusive ? Range.Boundary.including(value.toString().getBytes(StandardCharsets.UTF_8)) - : Range.Boundary.excluding(value.toString().getBytes(StandardCharsets.UTF_8)); - } - - return inclusive ? Range.Boundary.including((byte[]) value) : Range.Boundary.excluding((byte[]) value); - }; + return Range.from(upper, lower); } /** diff --git a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommands.java b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommands.java index 3bf31487f8..4c215d36d0 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommands.java @@ -37,7 +37,7 @@ import org.springframework.data.redis.connection.ReactiveRedisConnection.MultiValueResponse; import org.springframework.data.redis.connection.ReactiveRedisConnection.NumericResponse; import org.springframework.data.redis.connection.ReactiveZSetCommands; -import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.core.TimeoutUtils; 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 d57746f64e..372924036f 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 @@ -31,6 +31,7 @@ import org.springframework.data.redis.connection.RedisZSetCommands; import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs.Flag; import org.springframework.data.redis.connection.convert.Converters; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.Cursor; @@ -164,7 +165,7 @@ public Set zRangeWithScores(byte[] key, long start, long end) { } @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 +203,8 @@ public Set zRevRangeWithScores(byte[] key, long start, long end) { } @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 +223,7 @@ public Set zRevRangeByScore(byte[] key, Range range, org.springframework } @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 +243,7 @@ LettuceConverters. toRange(range), LettuceConverters.toLimit(limit)) } @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 +252,7 @@ public Long zCount(byte[] key, Range range) { } @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 +372,7 @@ public Long zRemRange(byte[] key, long start, long end) { } @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 +382,7 @@ public Long zRemRangeByLex(byte[] key, Range range) { } @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 +591,8 @@ public Set zRangeByScore(byte[] key, String min, String max, long offset } @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 +608,8 @@ public Set zRangeByScore(byte[] key, Range range, org.springframework.da } @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 +626,8 @@ public Set zRangeByLex(byte[] key, Range range, org.springframework.data } @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/connection/lettuce/RangeConverter.java b/src/main/java/org/springframework/data/redis/connection/lettuce/RangeConverter.java index f2c61550d1..71c2163813 100644 --- a/src/main/java/org/springframework/data/redis/connection/lettuce/RangeConverter.java +++ b/src/main/java/org/springframework/data/redis/connection/lettuce/RangeConverter.java @@ -19,8 +19,6 @@ import io.lettuce.core.Range.Boundary; import io.lettuce.core.codec.StringCodec; -import java.nio.ByteBuffer; -import java.util.function.BiFunction; import java.util.function.Function; import org.springframework.data.domain.Range.Bound; @@ -79,45 +77,50 @@ static Range toRangeWithDefault(org.springframework.data.domain.Range @SuppressWarnings("unchecked") private static Boundary lowerBoundArgOf(org.springframework.data.domain.Range range, @Nullable T lowerDefault, Function stringEncoder) { - return (Boundary) rangeToBoundArgumentConverter(false, stringEncoder).apply(range, lowerDefault); + return (Boundary) convertBound(range.getLowerBound(), false, lowerDefault, stringEncoder); } @SuppressWarnings("unchecked") private static Boundary upperBoundArgOf(org.springframework.data.domain.Range range, @Nullable T upperDefault, Function stringEncoder) { - return (Boundary) rangeToBoundArgumentConverter(true, stringEncoder).apply(range, upperDefault); + return (Boundary) convertBound(range.getUpperBound(), false, upperDefault, stringEncoder); } - private static BiFunction> rangeToBoundArgumentConverter( - boolean upper, Function stringEncoder) { + static Boundary convertBound(org.springframework.data.domain.Range.Bound source, boolean convertNumberToBytes, + Object defaultValue, Function stringEncoder) { - return (source, defaultValue) -> { + if (!source.isBounded()) { + return Boundary.unbounded(); + } - Boolean inclusive = upper ? source.getUpperBound().isInclusive() : source.getLowerBound().isInclusive(); - Object value = upper ? source.getUpperBound().getValue().orElse(defaultValue) - : source.getLowerBound().getValue().orElse(defaultValue); + Boolean inclusive = source.isInclusive(); + Object value = source.getValue().orElse(defaultValue); - if (value instanceof Number) { + if (value instanceof Number) { + + if (convertNumberToBytes) { + value = value.toString(); + } else { return inclusive ? Boundary.including((Number) value) : Boundary.excluding((Number) value); } + } - if (value instanceof String) { + if (value instanceof String) { - if (!StringUtils.hasText((String) value) || ObjectUtils.nullSafeEquals(value, "+") - || ObjectUtils.nullSafeEquals(value, "-")) { - return Boundary.unbounded(); - } + if (!StringUtils.hasText((String) value) || ObjectUtils.nullSafeEquals(value, "+") + || ObjectUtils.nullSafeEquals(value, "-")) { + return Boundary.unbounded(); + } - Object encoded = stringEncoder.apply((String) value); - return inclusive ? Boundary.including(encoded) : Boundary.excluding(encoded); + Object encoded = stringEncoder.apply((String) value); + return inclusive ? Boundary.including(encoded) : Boundary.excluding(encoded); - } + } - if (value == null) { - return Boundary.unbounded(); - } + if (value == null) { + return Boundary.unbounded(); + } - return inclusive ? Boundary.including((ByteBuffer) value) : Boundary.excluding((ByteBuffer) value); - }; + return inclusive ? Boundary.including(value) : Boundary.excluding(value); } } diff --git a/src/main/java/org/springframework/data/redis/connection/zset/Aggregate.java b/src/main/java/org/springframework/data/redis/connection/zset/Aggregate.java new file mode 100644 index 0000000000..559e7e4d42 --- /dev/null +++ b/src/main/java/org/springframework/data/redis/connection/zset/Aggregate.java @@ -0,0 +1,26 @@ +/* + * Copyright 2022 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.redis.connection.zset; + +/** + * Sort aggregation operations. + * + * @author Mark Paluch + * @since 3.0 + */ +public enum Aggregate { + SUM, MIN, MAX; +} 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 2dc8433ec6..2187cfef41 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.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.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.ZSetOperations.TypedTuple; @@ -301,9 +301,25 @@ public interface BoundZSetOperations extends BoundKeyOperations { * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZLEXCOUNT + * @deprecated since 3.0. Please use {@link #lexCount(Range)} instead. */ @Nullable - Long lexCount(Range range); + @Deprecated(since = "3.0", forRemoval = true) + default Long lexCount(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return lexCount(range.toRange()); + } + + /** + * Count number of elements within sorted set with value between {@link Range#getLowerBound()} and + * {@link Range#getUpperBound()} applying lexicographical ordering. + * + * @param range must not be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZLEXCOUNT + */ + @Nullable + Long lexCount(Range range); /** * Remove and return the value with its score having the lowest score from sorted set at the bound key. @@ -470,9 +486,24 @@ default TypedTuple popMax(Duration timeout) { * @return {@literal null} when used in pipeline / transaction. * @since 2.5 * @see Redis Documentation: ZREMRANGEBYLEX + * @deprecated since 3.0. Please use {@link #removeRangeByLex(Range)}. + */ + @Nullable + @Deprecated(since = "3.0", forRemoval = true) + default Long removeRangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return removeRangeByLex(range.toRange()); + } + + /** + * Remove elements in {@link Range} from sorted set with the bound key. + * + * @param range must not be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @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,60 +836,132 @@ default Set> unionWithScores(Collection otherKeys, Aggregate ag 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 org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 1.7 * @see Redis Documentation: ZRANGEBYLEX + * @deprecated since 3.0. Please use {@link #rangeByLex(Range)} instead. */ @Nullable - default Set rangeByLex(Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return rangeByLex(range.toRange()); + } + + /** + * 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. + * @since 3.0 + * @see Redis Documentation: ZRANGEBYLEX + */ + @Nullable + 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 from {@literal ZSET} at {@code key} with a value between + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 1.7 * @see Redis Documentation: ZRANGEBYLEX + * @deprecated since 3.0. Please use {@link #rangeByLex(Range, Limit)} instead. */ @Nullable - Set rangeByLex(Range range, Limit limit); + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range, Limit limit) { + return rangeByLex(range.toRange(), limit); + } /** - * Get all elements with reverse lexicographical ordering with a value between {@link Range#getMin()} and - * {@link Range#getMax()}. + * 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#getLowerBound()} and + * {@link Range#getUpperBound()}. + * + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZRANGEBYLEX + */ + @Nullable + Set rangeByLex(Range range, Limit limit); + + /** + * Get all elements with reverse lexicographical ordering from {@literal ZSET} with a value between + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZREVRANGEBYLEX + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Range)} instead. */ @Nullable - default Set reverseRangeByLex(Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return reverseRangeByLex(range); + } + + /** + * 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. + * @since 3.0 + * @see Redis Documentation: ZREVRANGEBYLEX + */ + @Nullable + 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 from {@literal ZSET} having a value + * between {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param range must not be {@literal null}. * @param limit can be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZREVRANGEBYLEX + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Range, Limit)} instead. + */ + @Nullable + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range, Limit limit) { + return reverseRangeByLex(range.toRange(), limit); + } + + /** + * 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#getLowerBound()} and {@link Range#getUpperBound()}. + * + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @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/DefaultReactiveZSetOperations.java b/src/main/java/org/springframework/data/redis/core/DefaultReactiveZSetOperations.java index c2e0413212..4d5b98cfb4 100644 --- a/src/main/java/org/springframework/data/redis/core/DefaultReactiveZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/DefaultReactiveZSetOperations.java @@ -31,7 +31,7 @@ import org.springframework.data.domain.Range; import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.ReactiveZSetCommands; -import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; 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 e04838179e..f0b4157a53 100644 --- a/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/DefaultZSetOperations.java @@ -22,10 +22,10 @@ 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.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.lang.Nullable; @@ -209,19 +209,19 @@ public Set> reverseRangeWithScores(K key, long start, long end) { } @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 @@ public Long removeRange(K key, long start, long end) { } @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 @@ public Long count(K key, double min, double max) { } @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 @@ public Set> popMin(K key, long count) { 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 @@ public Set> unionWithScores(K key, Collection otherKeys, Aggreg 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 @@ public Set rangeByScore(K key, String min, String max, long offset, long 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/ReactiveZSetOperations.java b/src/main/java/org/springframework/data/redis/core/ReactiveZSetOperations.java index 168e8ee265..f46a19f005 100644 --- a/src/main/java/org/springframework/data/redis/core/ReactiveZSetOperations.java +++ b/src/main/java/org/springframework/data/redis/core/ReactiveZSetOperations.java @@ -25,7 +25,7 @@ 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.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.ZSetOperations.TypedTuple; 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 280d325506..0b203a0e7f 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.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.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.lang.Nullable; @@ -402,17 +402,34 @@ static TypedTuple of(V value, @Nullable Double score) { 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}. * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZLEXCOUNT + * @deprecated since 3.0. Please use #lexCount(Range) instead. */ @Nullable - Long lexCount(K key, Range range); + @Deprecated(since = "3.0", forRemoval = true) + default Long lexCount(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return lexCount(key, range.toRange()); + } + + /** + * 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}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZLEXCOUNT + */ + @Nullable + Long lexCount(K key, Range range); /** * Remove and return the value with its score having the lowest score from sorted set at {@code key}. @@ -593,9 +610,25 @@ default TypedTuple popMax(K key, Duration timeout) { * @return {@literal null} when used in pipeline / transaction. * @since 2.5 * @see Redis Documentation: ZREMRANGEBYLEX + * @deprecated since 3.0. Please use {@link #removeRangeByLex(Object, Range)} instead; */ @Nullable - Long removeRangeByLex(K key, Range range); + @Deprecated(since = "3.0", forRemoval = true) + default Long removeRangeByLex(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return removeRangeByLex(key, range.toRange()); + } + + /** + * Remove elements in {@link Range} from sorted set with {@literal key}. + * + * @param key must not be {@literal null}. + * @param range must not be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZREMRANGEBYLEX + */ + @Nullable + Long removeRangeByLex(K key, Range range); /** * Remove elements with scores between {@code min} and {@code max} from sorted set with {@code key}. @@ -961,23 +994,42 @@ default Long unionAndStore(K key, Collection otherKeys, K destKey, Aggregate /** * Get all elements with lexicographical ordering from {@literal ZSET} at {@code key} with a value between - * {@link Range#getMin()} and {@link Range#getMax()}. + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 1.7 * @see Redis Documentation: ZRANGEBYLEX + * @deprecated since 3.0. Please use {@link #rangeByLex(Object, Range)} instead. */ @Nullable - default Set rangeByLex(K key, Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return rangeByLex(key, range.toRange()); + } + + /** + * Get all elements with lexicographical ordering from {@literal ZSET} at {@code key} with a value between + * {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. + * + * @param key must not be {@literal null}. + * @param range must not be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZRANGEBYLEX + */ + @Nullable + default Set rangeByLex(K key, Range range) { return rangeByLex(key, range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at * {@link Limit#getOffset()} with lexicographical ordering from {@literal ZSET} at {@code key} with a value between - * {@link Range#getMin()} and {@link Range#getMax()}. + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param key must not be {@literal null} * @param range must not be {@literal null}. @@ -985,29 +1037,88 @@ default Set rangeByLex(K key, Range range) { * @return {@literal null} when used in pipeline / transaction. * @since 1.7 * @see Redis Documentation: ZRANGEBYLEX + * @deprecated since 3.0. Please use {@link #rangeByLex(Object, Range, Limit)} instead. + */ + @Nullable + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, + Limit limit) { + return rangeByLex(key, range.toRange(), limit); + } + + /** + * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at + * {@link Limit#getOffset()} with lexicographical ordering from {@literal ZSET} at {@code key} with a value between + * {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. + * + * @param key must not be {@literal null} + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZRANGEBYLEX */ @Nullable - Set rangeByLex(K key, Range range, Limit limit); + Set rangeByLex(K key, Range range, Limit limit); /** * Get all elements with reverse lexicographical ordering from {@literal ZSET} at {@code key} with a value between - * {@link Range#getMin()} and {@link Range#getMax()}. + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. * * @param key must not be {@literal null}. * @param range must not be {@literal null}. * @return {@literal null} when used in pipeline / transaction. * @since 2.4 * @see Redis Documentation: ZREVRANGEBYLEX + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Object, Range)} */ @Nullable - default Set reverseRangeByLex(K key, Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return reverseRangeByLex(key, range.toRange()); + } + + /** + * Get all elements with reverse lexicographical ordering from {@literal ZSET} at {@code key} with a value between + * {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. + * + * @param key must not be {@literal null}. + * @param range must not be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 3.0 + * @see Redis Documentation: ZREVRANGEBYLEX + */ + @Nullable + default Set reverseRangeByLex(K key, Range range) { return reverseRangeByLex(key, range, Limit.unlimited()); } /** * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at * {@link Limit#getOffset()} with reverse lexicographical ordering from {@literal ZSET} at {@code key} with a value - * between {@link Range#getMin()} and {@link Range#getMax()}. + * between {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMin()} and + * {@link org.springframework.data.redis.connection.RedisZSetCommands.Range#getMax()}. + * + * @param key must not be {@literal null} + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return {@literal null} when used in pipeline / transaction. + * @since 2.4 + * @see Redis Documentation: ZREVRANGEBYLEX + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Object, Range, Limit)} instead. + */ + @Nullable + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(K key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, + Limit limit) { + return reverseRangeByLex(key, range.toRange(), limit); + } + + /** + * Get all elements {@literal n} elements, where {@literal n = } {@link Limit#getCount()}, starting at + * {@link Limit#getOffset()} with reverse lexicographical ordering from {@literal ZSET} at {@code key} with a value + * between {@link Range#getLowerBound()} and {@link Range#getUpperBound()}. * * @param key must not be {@literal null} * @param range must not be {@literal null}. @@ -1017,7 +1128,7 @@ default Set reverseRangeByLex(K key, Range range) { * @see Redis Documentation: ZREVRANGEBYLEX */ @Nullable - Set reverseRangeByLex(K key, Range range, Limit limit); + Set reverseRangeByLex(K key, 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 f28421c2a5..7ad7db419e 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.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 Set reverseRange(long start, long end) { } @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 RedisZSet remove(long start, long end) { } @Override - public Set removeByLex(Range range) { + public Set removeByLex(Range range) { boundZSetOps.removeRangeByLex(range); return this; } @@ -424,7 +424,7 @@ public Long reverseRank(Object o) { } @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 3d2db6f586..b22c2fb853 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.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,56 +263,121 @@ static RedisZSet create(String key, RedisOperations operations 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 + * @deprecated since 3.0. Please use {@link #rangeByLex(Range)} instead. */ - default Set rangeByLex(Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return rangeByLex(range.toRange()); + } + + /** + * 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 3.0 + */ + 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}. * @return * @since 1.7 * @see BoundZSetOperations#rangeByLex(Range, Limit) + * @deprecated since 3.0. Please use {@link #rangeByLex(Range, Limit)} instead. + */ + @Deprecated(since = "3.0", forRemoval = true) + default Set rangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range, Limit limit) { + return rangeByLex(range.toRange(), limit); + } + + /** + * 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#getLowerBound()} and + * {@link Range#getUpperBound()}. + * + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return + * @since 3.0 + * @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) + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Range, Limit)} instead. */ - default Set reverseRangeByLex(Range range) { + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range) { + return reverseRangeByLex(range.toRange()); + } + + /** + * 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 3.0 + * @see BoundZSetOperations#reverseRangeByLex(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}. * @return * @since 2.4 * @see BoundZSetOperations#reverseRangeByLex(Range, Limit) + * @deprecated since 3.0. Please use {@link #reverseRangeByLex(Range, Limit)} instead. + */ + @Deprecated(since = "3.0", forRemoval = true) + default Set reverseRangeByLex(org.springframework.data.redis.connection.RedisZSetCommands.Range range, + Limit limit) { + return reverseRangeByLex(range.toRange(), limit); + } + + /** + * 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#getLowerBound()} and {@link Range#getUpperBound()}. + * + * @param range must not be {@literal null}. + * @param limit can be {@literal null}. + * @return + * @since 3.0 + * @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 +451,7 @@ default Set reverseRangeByLex(Range range) { * @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 +478,8 @@ default Set reverseRangeByLex(Range range) { 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 +508,7 @@ default boolean addIfAbsent(E e) { * @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/main/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensions.kt b/src/main/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensions.kt index 03ead1eb69..5c0ad2f158 100644 --- a/src/main/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensions.kt +++ b/src/main/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensions.kt @@ -21,7 +21,7 @@ import kotlinx.coroutines.reactive.awaitFirstOrNull import kotlinx.coroutines.reactive.awaitSingle import org.springframework.data.domain.Range import org.springframework.data.redis.connection.Limit -import org.springframework.data.redis.connection.RedisZSetCommands +import org.springframework.data.redis.connection.zset.Aggregate import org.springframework.data.redis.connection.zset.Weights import org.springframework.data.redis.core.ZSetOperations.TypedTuple @@ -229,8 +229,13 @@ suspend fun ReactiveZSetOperations.unionAndStoreAndAwai * @author Mark Paluch * @since 2.2 */ -suspend fun ReactiveZSetOperations.unionAndStoreAndAwait(key: K, otherKeys: Collection, destKey: K, aggregate: RedisZSetCommands.Aggregate): Long = - unionAndStore(key, otherKeys, destKey, aggregate).awaitSingle() +suspend fun ReactiveZSetOperations.unionAndStoreAndAwait( + key: K, + otherKeys: Collection, + destKey: K, + aggregate: Aggregate +): Long = + unionAndStore(key, otherKeys, destKey, aggregate).awaitSingle() /** * Coroutines variant of [ReactiveZSetOperations.unionAndStore]. @@ -242,7 +247,7 @@ suspend fun ReactiveZSetOperations.unionAndStoreAndAwai key: K, otherKeys: Collection, destKey: K, - aggregate: RedisZSetCommands.Aggregate, + aggregate: Aggregate, weights: Weights ): Long = unionAndStore(key, otherKeys, destKey, aggregate, weights).awaitSingle() @@ -271,8 +276,13 @@ suspend fun ReactiveZSetOperations.intersectAndStoreAnd * @author Mark Paluch * @since 2.2 */ -suspend fun ReactiveZSetOperations.intersectAndStoreAndAwait(key: K, otherKeys: Collection, destKey: K, aggregate: RedisZSetCommands.Aggregate): Long = - intersectAndStore(key, otherKeys, destKey, aggregate).awaitSingle() +suspend fun ReactiveZSetOperations.intersectAndStoreAndAwait( + key: K, + otherKeys: Collection, + destKey: K, + aggregate: Aggregate +): Long = + intersectAndStore(key, otherKeys, destKey, aggregate).awaitSingle() /** * Coroutines variant of [ReactiveZSetOperations.intersectAndStore]. @@ -284,7 +294,7 @@ suspend fun ReactiveZSetOperations.intersectAndStoreAnd key: K, otherKeys: Collection, destKey: K, - aggregate: RedisZSetCommands.Aggregate, + aggregate: Aggregate, weights: Weights ): Long = intersectAndStore(key, otherKeys, destKey, aggregate, weights).awaitSingle() 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 4b5a67cd4c..c82c03d09c 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.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; @@ -58,8 +59,6 @@ import org.springframework.data.redis.connection.RedisStreamCommands.XClaimOptions; 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; @@ -75,6 +74,7 @@ import org.springframework.data.redis.connection.stream.StreamInfo.XInfoStream; import org.springframework.data.redis.connection.stream.StreamOffset; import org.springframework.data.redis.connection.stream.StringRecord; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.core.Cursor; @@ -1938,10 +1938,10 @@ void zLexCountTest() { 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 @@ void testZRemRangeByLex() { 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 @@ void zRangeByLexTest() { 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 void zRevRangeByLexTest() { 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/DefaultStringRedisConnectionTests.java b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java index 8d82616931..7191f8d80d 100644 --- a/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java +++ b/src/test/java/org/springframework/data/redis/connection/DefaultStringRedisConnectionTests.java @@ -49,7 +49,6 @@ import org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption; import org.springframework.data.redis.connection.RedisStreamCommands.XAddOptions; import org.springframework.data.redis.connection.RedisStringCommands.BitOperation; -import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; import org.springframework.data.redis.connection.StringRedisConnection.StringTuple; import org.springframework.data.redis.connection.convert.Converters; import org.springframework.data.redis.connection.stream.Consumer; @@ -58,6 +57,7 @@ import org.springframework.data.redis.connection.stream.StreamOffset; import org.springframework.data.redis.connection.stream.StreamReadOptions; import org.springframework.data.redis.connection.stream.StreamRecords; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.DefaultTuple; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; 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 0036902e81..9482de3dca 100644 --- a/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java +++ b/src/test/java/org/springframework/data/redis/connection/RedisConnectionUnitTests.java @@ -35,6 +35,7 @@ import org.springframework.data.geo.Metric; import org.springframework.data.geo.Point; import org.springframework.data.redis.connection.RedisNode.RedisNodeBuilder; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Tuple; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.Cursor; @@ -1000,70 +1001,72 @@ public Set zRangeByLex(byte[] key) { } @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 7a4c82400e..b5f71b93ec 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 void zRangeByLexShouldReturnResultCorrectly() { 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 void zRevRangeByLexShouldReturnValuesCorrectly() { 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 7bdd6b1b29..9e6c845786 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 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 @@ void boundaryToBytesForZRangeByLexShouldReturnDefaultValueWhenBoundaryValueIsNul 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 @@ void boundaryToBytesForZRangeByShouldReturnDefaultValueWhenBoundaryValueIsNull() 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 3a46192be3..bf9f09adc1 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 void zRangeByLexShouldReturnResultCorrectly() { 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 void zRevRangeByLexShouldReturnValuesCorrectly() { 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/DefaultReactiveZSetOperationsIntegrationTests.java b/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java index 654f8d83bf..451ff8e761 100644 --- a/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java @@ -35,7 +35,7 @@ import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.RedisConnection; import org.springframework.data.redis.connection.RedisConnectionFactory; -import org.springframework.data.redis.connection.RedisZSetCommands.Aggregate; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.ReactiveOperationsTestParams.Fixture; import org.springframework.data.redis.serializer.RedisSerializer; 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 ae9347c3b4..bbc2988c25 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 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; @@ -36,7 +37,7 @@ import org.springframework.data.redis.ObjectFactory; import org.springframework.data.redis.RawObjectFactory; import org.springframework.data.redis.connection.Limit; -import org.springframework.data.redis.connection.RedisZSetCommands; +import org.springframework.data.redis.connection.zset.Aggregate; import org.springframework.data.redis.connection.zset.Weights; import org.springframework.data.redis.core.ZSetOperations.TypedTuple; import org.springframework.data.redis.test.condition.EnabledOnCommand; @@ -112,7 +113,7 @@ void testLexCountUnbounded() { 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 @@ void testLexCountBounded() { 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 @@ void testRangeByLexUnbounded() { 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 @@ void testRangeByLexBounded() { 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 @@ void testRangeByLexUnboundedWithLimit() { 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 @@ void testReverseRangeByLexUnboundedWithLimit() { 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 @@ void testRangeByLexBoundedWithLimit() { 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); @@ -577,10 +576,10 @@ void testZsetIntersectWithAggregate() { zSetOps.add(key1, value2, 2.0); zSetOps.add(key2, value2, 3.0); - assertThat(zSetOps.intersectWithScores(key1, Collections.singletonList(key2), RedisZSetCommands.Aggregate.MIN)) + assertThat(zSetOps.intersectWithScores(key1, Collections.singletonList(key2), Aggregate.MIN)) .contains(new DefaultTypedTuple<>(value2, 2d)); - zSetOps.intersectAndStore(key1, Collections.singletonList(key2), key1, RedisZSetCommands.Aggregate.MIN); + zSetOps.intersectAndStore(key1, Collections.singletonList(key2), key1, Aggregate.MIN); assertThat(zSetOps.score(key1, value2)).isCloseTo(2.0, offset(0.1)); } @@ -594,7 +593,7 @@ void testZsetIntersectWithAggregateWeights() { zSetOps.add(key1, value1, 4.0); zSetOps.add(key2, value1, 3.0); - zSetOps.intersectAndStore(key1, Collections.singletonList(key2), key1, RedisZSetCommands.Aggregate.MAX, + zSetOps.intersectAndStore(key1, Collections.singletonList(key2), key1, Aggregate.MAX, Weights.of(1, 2)); assertThat(zSetOps.score(key1, value1)).isCloseTo(6.0, offset(0.1)); @@ -634,7 +633,7 @@ void testZsetUnionWithAggregate() { assertThat(zSetOps.unionWithScores(key1, Collections.singletonList(key2))) .containsOnly(new DefaultTypedTuple<>(value1, 1d), new DefaultTypedTuple<>(value2, 5d)); - zSetOps.unionAndStore(key1, Collections.singletonList(key2), key1, RedisZSetCommands.Aggregate.MIN); + zSetOps.unionAndStore(key1, Collections.singletonList(key2), key1, Aggregate.MIN); assertThat(zSetOps.score(key1, value2)).isCloseTo(2.0, offset(0.1)); } @@ -649,7 +648,7 @@ void testZsetUnionWithAggregateWeights() { zSetOps.add(key1, value1, 4.0); zSetOps.add(key2, value1, 3.0); - zSetOps.unionAndStore(key1, Collections.singletonList(key2), key1, RedisZSetCommands.Aggregate.MAX, + zSetOps.unionAndStore(key1, Collections.singletonList(key2), key1, Aggregate.MAX, Weights.of(1, 2)); assertThat(zSetOps.score(key1, value1)).isCloseTo(6.0, offset(0.1)); 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 e0a224ad67..855a269222 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 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 @@ void beforeEach() { @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 15bcc2ac58..295aa27bb5 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 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 @@ void testLexCountUnbounded() { 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 @@ void testLexCountBounded() { 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 @@ void testRangeByLexUnbounded() { 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 @@ void testRangeByLexBounded() { 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 @@ void testRangeByLexUnboundedWithLimit() { 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 @@ void testRangeByLexUnboundedWithLimit() { @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 @@ void testRangeByLexBoundedWithLimit() { 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 @@ void testReverseRangeByLexBoundedWithLimit() { 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 @@ void testZAddIfAbsentWorks() { @EnabledOnCommand("ZRANDMEMBER") void randMemberReturnsSomething() { - Object[] valuesArray = new Object[]{getT(), getT(), getT()}; + Object[] valuesArray = new Object[] { getT(), getT(), getT() }; collection.addAll((List) Arrays.asList(valuesArray)); diff --git a/src/test/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensionsUnitTests.kt b/src/test/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensionsUnitTests.kt index 36821190bf..aa91d1cc28 100644 --- a/src/test/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensionsUnitTests.kt +++ b/src/test/kotlin/org/springframework/data/redis/core/ReactiveZSetOperationsExtensionsUnitTests.kt @@ -24,7 +24,7 @@ import org.assertj.core.api.Assertions.assertThat import org.junit.jupiter.api.Test 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.zset.Aggregate import org.springframework.data.redis.connection.zset.Weights import org.springframework.data.redis.core.ZSetOperations.TypedTuple import reactor.core.publisher.Flux