From 15e21f05f51d7f8725eabc351f031a44c782de10 Mon Sep 17 00:00:00 2001 From: Nikita Koksharov Date: Mon, 3 Jul 2023 08:03:37 +0300 Subject: [PATCH] Fixed - Missed methods implementation of Spring Data Redis module: zRevRangeByLex(), time(TimeUnit), zRemRangeByLex(), zLexCount(), rewriteConfig(), zRangeStoreByLex(), zRangeStoreRevByLex(), zRangeStoreByScore(), zRangeStoreRevByScore(), flushDb(), flushAll(), replicaOf(), replicaOfNoOne() #5144 --- .../data/connection/RedissonConnection.java | 38 +++- .../data/connection/RedissonConnection.java | 59 +++++- .../data/connection/RedissonConnection.java | 58 +++++- .../data/connection/RedissonConnection.java | 68 ++++++- .../data/connection/RedissonConnection.java | 174 ++++++++++++++++- .../data/connection/RedissonConnection.java | 175 +++++++++++++++++- .../connection/RedissonConnectionTest.java | 51 ++++- .../client/protocol/RedisCommands.java | 1 + .../decoder/TimeLongObjectDecoder.java | 17 +- 9 files changed, 592 insertions(+), 49 deletions(-) diff --git a/redisson-spring-data/redisson-spring-data-24/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-24/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index f82902edc..520987896 100644 --- a/redisson-spring-data/redisson-spring-data-24/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-24/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -1751,13 +1751,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2260,4 +2253,35 @@ public class RedissonConnection extends AbstractRedisConnection { restore(key, ttlInMillis, serializedValue); } + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, Range range, Limit limit) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + } diff --git a/redisson-spring-data/redisson-spring-data-25/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-25/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index 00d954271..ae9b330d4 100644 --- a/redisson-spring-data/redisson-spring-data-25/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-25/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -1790,13 +1790,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2299,4 +2292,56 @@ public class RedissonConnection extends AbstractRedisConnection { restore(key, ttlInMillis, serializedValue); } + + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, Range range, Limit limit) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + @Override + public Long time(TimeUnit timeUnit) { + return read(null, LongCodec.INSTANCE, new RedisStrictCommand<>("TIME", new TimeLongObjectDecoder(timeUnit))); + } + + private static final RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand<>("ZREMRANGEBYLEX"); + + @Override + public Long zRemRangeByLex(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return write(key, StringCodec.INSTANCE, ZREMRANGEBYLEX, key, min, max); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + + @Override + public void rewriteConfig() { + write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_REWRITE); + } + } diff --git a/redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index 8c2d70b44..2504fb791 100644 --- a/redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -1795,13 +1795,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2756,4 +2749,55 @@ public class RedissonConnection extends AbstractRedisConnection { return write(key, ByteArrayCodec.INSTANCE, GETDEL, key); } + + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, Range range, Limit limit) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + @Override + public Long time(TimeUnit timeUnit) { + return read(null, LongCodec.INSTANCE, new RedisStrictCommand<>("TIME", new TimeLongObjectDecoder(timeUnit))); + } + + private static final RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand<>("ZREMRANGEBYLEX"); + + @Override + public Long zRemRangeByLex(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return write(key, StringCodec.INSTANCE, ZREMRANGEBYLEX, key, min, max); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + + @Override + public void rewriteConfig() { + write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_REWRITE); + } } diff --git a/redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index 8bee3103c..92ea2f7aa 100644 --- a/redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -1795,13 +1795,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2756,4 +2749,65 @@ public class RedissonConnection extends AbstractRedisConnection { return write(key, ByteArrayCodec.INSTANCE, GETDEL, key); } + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, Range range, Limit limit) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + @Override + public Long time(TimeUnit timeUnit) { + return read(null, LongCodec.INSTANCE, new RedisStrictCommand<>("TIME", new TimeLongObjectDecoder(timeUnit))); + } + + private static final RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand<>("ZREMRANGEBYLEX"); + + @Override + public Long zRemRangeByLex(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return write(key, StringCodec.INSTANCE, ZREMRANGEBYLEX, key, min, max); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, Range range) { + String min = value(range.getMin(), "-"); + String max = value(range.getMax(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + + @Override + public void rewriteConfig() { + write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_REWRITE); + } + + @Override + public void flushDb(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHDB, option.toString()); + } + + @Override + public void flushAll(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHALL, option.toString()); + } + } diff --git a/redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index 25202d7b9..6a0fe295b 100644 --- a/redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -52,7 +52,6 @@ import org.springframework.data.redis.domain.geo.RadiusShape; import org.springframework.util.Assert; import org.springframework.util.ObjectUtils; import org.springframework.util.ReflectionUtils; -import org.springframework.data.domain.Range; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -1721,13 +1720,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2682,6 +2674,172 @@ public class RedissonConnection extends AbstractRedisConnection { return write(key, ByteArrayCodec.INSTANCE, GETDEL, key); } + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + @Override + public Long time(TimeUnit timeUnit) { + return read(null, LongCodec.INSTANCE, new RedisStrictCommand<>("TIME", new TimeLongObjectDecoder(timeUnit))); + } + + private static final RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand<>("ZREMRANGEBYLEX"); + + @Override + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + return write(key, StringCodec.INSTANCE, ZREMRANGEBYLEX, key, min, max); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, org.springframework.data.domain.Range range) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + + @Override + public void rewriteConfig() { + write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_REWRITE); + } + + public static final RedisCommand ZRANGESTORE = new RedisCommand<>("ZRANGESTORE"); + + @Override + public Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String max = value(range.getUpperBound(), "+"); + String min = value(range.getLowerBound(), "-"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYLEX"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String max = value(range.getUpperBound(), "+"); + String min = value(range.getLowerBound(), "-"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYLEX"); + + args.add("REV"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-inf"); + String max = value(range.getUpperBound(), "+inf"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYSCORE"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-inf"); + String max = value(range.getUpperBound(), "+inf"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYSCORE"); + + args.add("REV"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public void flushDb(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHDB, option.toString()); + } + + @Override + public void flushAll(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHALL, option.toString()); + } + + private static final RedisStrictCommand REPLICAOF = new RedisStrictCommand<>("REPLICAOF"); + + @Override + public void replicaOf(String host, int port) { + write(null, StringCodec.INSTANCE, REPLICAOF, host, port); + } + + @Override + public void replicaOfNoOne() { + write(null, StringCodec.INSTANCE, REPLICAOF, "NO", "ONE"); + } @Override public org.springframework.data.redis.connection.RedisCommands commands() { return this; diff --git a/redisson-spring-data/redisson-spring-data-31/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java b/redisson-spring-data/redisson-spring-data-31/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java index 25202d7b9..f9587aa08 100644 --- a/redisson-spring-data/redisson-spring-data-31/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java +++ b/redisson-spring-data/redisson-spring-data-31/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java @@ -52,7 +52,6 @@ import org.springframework.data.redis.domain.geo.RadiusShape; import org.springframework.util.Assert; import org.springframework.util.ObjectUtils; import org.springframework.util.ReflectionUtils; -import org.springframework.data.domain.Range; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -1721,13 +1720,6 @@ public class RedissonConnection extends AbstractRedisConnection { write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_RESETSTAT); } - private static final RedisStrictCommand TIME = new RedisStrictCommand("TIME", new TimeLongObjectDecoder()); - - @Override - public Long time() { - return read(null, LongCodec.INSTANCE, TIME); - } - @Override public void killClient(String host, int port) { throw new UnsupportedOperationException(); @@ -2682,6 +2674,173 @@ public class RedissonConnection extends AbstractRedisConnection { return write(key, ByteArrayCodec.INSTANCE, GETDEL, key); } + private static final RedisCommand> ZREVRANGEBYLEX = new RedisCommand<>("ZREVRANGEBYLEX", new ObjectSetReplayDecoder()); + + @Override + public Set zRevRangeByLex(byte[] key, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + List args = new ArrayList(); + args.add(key); + args.add(max); + args.add(min); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return read(key, ByteArrayCodec.INSTANCE, ZREVRANGEBYLEX, args.toArray()); + } + + @Override + public Long time(TimeUnit timeUnit) { + return read(null, LongCodec.INSTANCE, new RedisStrictCommand<>("TIME", new TimeLongObjectDecoder(timeUnit))); + } + + private static final RedisStrictCommand ZREMRANGEBYLEX = new RedisStrictCommand<>("ZREMRANGEBYLEX"); + + @Override + public Long zRemRangeByLex(byte[] key, org.springframework.data.domain.Range range) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + return write(key, StringCodec.INSTANCE, ZREMRANGEBYLEX, key, min, max); + } + + private static final RedisStrictCommand ZLEXCOUNT = new RedisStrictCommand<>("ZLEXCOUNT"); + + @Override + public Long zLexCount(byte[] key, org.springframework.data.domain.Range range) { + String min = value(range.getLowerBound(), "-"); + String max = value(range.getUpperBound(), "+"); + + return read(key, StringCodec.INSTANCE, ZLEXCOUNT, key, min, max); + } + + @Override + public void rewriteConfig() { + write(null, StringCodec.INSTANCE, RedisCommands.CONFIG_REWRITE); + } + + public static final RedisCommand ZRANGESTORE = new RedisCommand<>("ZRANGESTORE"); + + @Override + public Long zRangeStoreByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String max = value(range.getUpperBound(), "+"); + String min = value(range.getLowerBound(), "-"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYLEX"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreRevByLex(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String max = value(range.getUpperBound(), "+"); + String min = value(range.getLowerBound(), "-"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYLEX"); + + args.add("REV"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-inf"); + String max = value(range.getUpperBound(), "+inf"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYSCORE"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public Long zRangeStoreRevByScore(byte[] dstKey, byte[] srcKey, org.springframework.data.domain.Range range, org.springframework.data.redis.connection.Limit limit) { + String min = value(range.getLowerBound(), "-inf"); + String max = value(range.getUpperBound(), "+inf"); + + List args = new LinkedList<>(); + args.add(dstKey); + args.add(srcKey); + args.add(min); + args.add(max); + + args.add("BYSCORE"); + + args.add("REV"); + + if (!limit.isUnlimited()) { + args.add("LIMIT"); + args.add(limit.getOffset()); + args.add(limit.getCount()); + } + + return write(srcKey, LongCodec.INSTANCE, ZRANGESTORE, args.toArray()); + } + + @Override + public void flushDb(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHDB, option.toString()); + } + + @Override + public void flushAll(FlushOption option) { + write(null, StringCodec.INSTANCE, RedisCommands.FLUSHALL, option.toString()); + } + + private static final RedisStrictCommand REPLICAOF = new RedisStrictCommand<>("REPLICAOF"); + + @Override + public void replicaOf(String host, int port) { + write(null, StringCodec.INSTANCE, REPLICAOF, host, port); + } + + @Override + public void replicaOfNoOne() { + write(null, StringCodec.INSTANCE, REPLICAOF, "NO", "ONE"); + } + @Override public org.springframework.data.redis.connection.RedisCommands commands() { return this; diff --git a/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/spring/data/connection/RedissonConnectionTest.java b/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/spring/data/connection/RedissonConnectionTest.java index e3cc8a862..165e7fac8 100644 --- a/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/spring/data/connection/RedissonConnectionTest.java +++ b/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/spring/data/connection/RedissonConnectionTest.java @@ -3,17 +3,16 @@ package org.redisson.spring.data.connection; import static org.assertj.core.api.Assertions.assertThat; import org.junit.Test; +import org.springframework.data.domain.Range; import org.springframework.data.geo.Circle; import org.springframework.data.geo.GeoResults; import org.springframework.data.geo.Point; +import org.springframework.data.redis.connection.Limit; import org.springframework.data.redis.connection.RedisGeoCommands; import org.springframework.data.redis.connection.RedisStringCommands.SetOption; import org.springframework.data.redis.connection.RedisZSetCommands; import org.springframework.data.redis.connection.zset.Tuple; -import org.springframework.data.redis.core.Cursor; -import org.springframework.data.redis.core.RedisTemplate; -import org.springframework.data.redis.core.ScanOptions; -import org.springframework.data.redis.core.SetOperations; +import org.springframework.data.redis.core.*; import org.springframework.data.redis.core.types.Expiration; import java.util.List; @@ -22,6 +21,50 @@ import java.util.Set; public class RedissonConnectionTest extends BaseConnectionTest { + @Test + public void testZLexCount() { + StringRedisTemplate redisTemplate = new StringRedisTemplate(); + redisTemplate.setConnectionFactory(new RedissonConnectionFactory(redisson)); + redisTemplate.afterPropertiesSet(); + + redisTemplate.boundZSetOps("test").add("1", 10); + redisTemplate.boundZSetOps("test").add("2", 20); + redisTemplate.boundZSetOps("test").add("3", 30); + + Long size = redisTemplate.boundZSetOps("test").lexCount(Range.closed("1", "2")); + assertThat(size).isEqualTo(2); + } + + @Test + public void testZRemLexByRange() { + StringRedisTemplate redisTemplate = new StringRedisTemplate(); + redisTemplate.setConnectionFactory(new RedissonConnectionFactory(redisson)); + redisTemplate.afterPropertiesSet(); + + redisTemplate.boundZSetOps("test").add("1", 10); + redisTemplate.boundZSetOps("test").add("2", 20); + redisTemplate.boundZSetOps("test").add("3", 30); + + Long size = redisTemplate.boundZSetOps("test") + .removeRangeByLex(Range.closed("1", "2")); + assertThat(size).isEqualTo(2); + } + + @Test + public void testReverseRangeByLex() { + StringRedisTemplate redisTemplate = new StringRedisTemplate(); + redisTemplate.setConnectionFactory(new RedissonConnectionFactory(redisson)); + redisTemplate.afterPropertiesSet(); + + redisTemplate.boundZSetOps("test").add("1", 10); + redisTemplate.boundZSetOps("test").add("2", 20); + + Set ops = redisTemplate.boundZSetOps("test") + .reverseRangeByLex(Range.closed("1", "2") + , Limit.limit().count(10)); + assertThat(ops.size()).isEqualTo(2); + } + @Test public void testExecute() { Long s = (Long) connection.execute("ttl", "key".getBytes()); diff --git a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java index 338bf16fc..0b6193ef2 100644 --- a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java +++ b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java @@ -698,6 +698,7 @@ public interface RedisCommands { RedisStrictCommand> CONFIG_GET_MAP = new RedisStrictCommand<>("CONFIG", "GET", new ObjectMapReplayDecoder()); RedisStrictCommand CONFIG_SET = new RedisStrictCommand("CONFIG", "SET", new VoidReplayConvertor()); RedisStrictCommand CONFIG_RESETSTAT = new RedisStrictCommand("CONFIG", "RESETSTAT", new VoidReplayConvertor()); + RedisStrictCommand CONFIG_REWRITE = new RedisStrictCommand<>("CONFIG", "REWRITE", new VoidReplayConvertor()); RedisStrictCommand> CLIENT_LIST = new RedisStrictCommand>("CLIENT", "LIST", new StringToListConvertor()); RedisStrictCommand> INFO_ALL = new RedisStrictCommand>("INFO", "ALL", new StringMapDataDecoder()); diff --git a/redisson/src/main/java/org/redisson/client/protocol/decoder/TimeLongObjectDecoder.java b/redisson/src/main/java/org/redisson/client/protocol/decoder/TimeLongObjectDecoder.java index cd4ccb5e9..895c1b22a 100644 --- a/redisson/src/main/java/org/redisson/client/protocol/decoder/TimeLongObjectDecoder.java +++ b/redisson/src/main/java/org/redisson/client/protocol/decoder/TimeLongObjectDecoder.java @@ -18,6 +18,7 @@ package org.redisson.client.protocol.decoder; import org.redisson.client.handler.State; import java.util.List; +import java.util.concurrent.TimeUnit; /** * @@ -27,9 +28,23 @@ import java.util.List; public class TimeLongObjectDecoder implements MultiDecoder { + private final TimeUnit timeUnit; + + public TimeLongObjectDecoder() { + this(null); + } + + public TimeLongObjectDecoder(TimeUnit timeUnit) { + this.timeUnit = timeUnit; + } + @Override public Long decode(List parts, State state) { - return ((Long) parts.get(0)) * 1000L + ((Long) parts.get(1)) / 1000L; + long time = ((Long) parts.get(0)) * 1000L + ((Long) parts.get(1)) / 1000L; + if (timeUnit != null) { + return timeUnit.convert(time, TimeUnit.MILLISECONDS); + } + return time; } }