Merge pull request #282 from jackygurui/master

lexRange related methods with limit options and zrangebyscore support

src/main/java/org/redisson/RedissonLexSortedSet.java

@@ -103,6 +103,41 @@ public class RedissonLexSortedSet extends RedissonScoredSortedSet<String> implem
         return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), fromValue, toValue);
     }
 
+    @Override
+    public Collection<String> lexRange(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count) {
+        return get(lexRangeAsync(fromElement, fromInclusive, toElement, toInclusive, offset, count));
+    }
+
+    @Override
+    public Collection<String> lexRangeHead(String toElement, boolean toInclusive, int offset, int count) {
+        return get(lexRangeHeadAsync(toElement, toInclusive, offset, count));
+    }
+
+    @Override
+    public Future<Collection<String>> lexRangeHeadAsync(String toElement, boolean toInclusive, int offset, int count) {
+        String toValue = value(toElement, toInclusive);
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), "-", toValue, "LIMIT", offset, count);
+    }
+
+    @Override
+    public Collection<String> lexRangeTail(String fromElement, boolean fromInclusive, int offset, int count) {
+        return get(lexRangeTailAsync(fromElement, fromInclusive, offset, count));
+    }
+
+    @Override
+    public Future<Collection<String>> lexRangeTailAsync(String fromElement, boolean fromInclusive, int offset, int count) {
+        String fromValue = value(fromElement, fromInclusive);
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), fromValue, "+", "LIMIT", offset, count);
+    }
+
+    @Override
+    public Future<Collection<String>> lexRangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count) {
+        String fromValue = value(fromElement, fromInclusive);
+        String toValue = value(toElement, toInclusive);
+
+        return commandExecutor.readAsync(getName(), StringCodec.INSTANCE, RedisCommands.ZRANGEBYLEX, getName(), fromValue, toValue, "LIMIT", offset, count);
+    }
+
     @Override
     public int lexCountTail(String fromElement, boolean fromInclusive) {
         return get(lexCountTailAsync(fromElement, fromInclusive));

src/main/java/org/redisson/RedissonScoredSortedSet.java

@@ -321,4 +321,52 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
         return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGE_ENTRY, getName(), startIndex, endIndex, "WITHSCORES");
     }
 
+    @Override
+    public Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive) {
+        return get(valueRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive));
+    }
+
+    @Override
+    public Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE, getName(), startValue, endValue);
+    }
+
+    @Override
+    public Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive) {
+        return get(entryRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive));
+    }
+
+    @Override
+    public Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE_ENTRY, getName(), startValue, endValue, "WITHSCORES");
+    }
+
+    @Override
+    public Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        return get(valueRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive, offset, count));
+    }
+
+    @Override
+    public Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE, getName(), startValue, endValue, "LIMIT", offset, count);
+    }
+
+    @Override
+    public Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        return get(entryRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive, offset, count));
+    }
+
+    @Override
+    public Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE_ENTRY, getName(), startValue, endValue, "WITHSCORES", "LIMIT", offset, count);
+    }
+
 }

src/main/java/org/redisson/client/protocol/RedisCommands.java

@@ -72,7 +72,9 @@ public interface RedisCommands {
     RedisStrictCommand<Integer> ZREMRANGEBYSCORE = new RedisStrictCommand<Integer>("ZREMRANGEBYSCORE", new IntegerReplayConvertor());
     RedisStrictCommand<Integer> ZREMRANGEBYLEX = new RedisStrictCommand<Integer>("ZREMRANGEBYLEX", new IntegerReplayConvertor());
     RedisCommand<List<Object>> ZRANGEBYLEX = new RedisCommand<List<Object>>("ZRANGEBYLEX", new ObjectListReplayDecoder<Object>());
+    RedisCommand<List<Object>> ZRANGEBYSCORE = new RedisCommand<List<Object>>("ZRANGEBYSCORE", new ObjectListReplayDecoder<Object>());
     RedisCommand<List<ScoredEntry<Object>>> ZRANGE_ENTRY = new RedisCommand<List<ScoredEntry<Object>>>("ZRANGE", new ScoredSortedSetReplayDecoder<Object>());
+    RedisCommand<List<ScoredEntry<Object>>> ZRANGEBYSCORE_ENTRY = new RedisCommand<List<ScoredEntry<Object>>>("ZRANGEBYSCORE", new ScoredSortedSetReplayDecoder<Object>());
     RedisCommand<ListScanResult<Object>> ZSCAN = new RedisCommand<ListScanResult<Object>>("ZSCAN", new NestedMultiDecoder(new ObjectListReplayDecoder<Object>(), new ScoredSortedSetScanReplayDecoder()), ValueType.OBJECT);
     RedisStrictCommand<Double> ZINCRBY = new RedisStrictCommand<Double>("ZINCRBY", new DoubleReplayConvertor());
 

src/main/java/org/redisson/connection/SentinelConnectionManager.java

@@ -105,6 +105,7 @@ public class SentinelConnectionManager extends MasterSlaveConnectionManager {
                             disconnectedSlaves.add(host);
                         }
                     }
+                }
                 break;
             } catch (RedisConnectionException e) {
                 log.warn("can't connect to sentinel", e);

src/main/java/org/redisson/core/RLexSortedSet.java

@@ -36,6 +36,12 @@ public interface RLexSortedSet extends RLexSortedSetAsync, Set<String>, RExpirab
 
     Collection<String> lexRange(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive);
 
+    Collection<String> lexRangeTail(String fromElement, boolean fromInclusive, int offset, int count);
+
+    Collection<String> lexRangeHead(String toElement, boolean toInclusive, int offset, int count);
+
+    Collection<String> lexRange(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count);
+
     int lexCount(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive);
 
     int rank(String o);

src/main/java/org/redisson/core/RLexSortedSetAsync.java

@@ -37,6 +37,12 @@ public interface RLexSortedSetAsync extends RCollectionAsync<String> {
 
     Future<Collection<String>> lexRangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive);
 
+    Future<Collection<String>> lexRangeTailAsync(String fromElement, boolean fromInclusive, int offset, int count);
+
+    Future<Collection<String>> lexRangeHeadAsync(String toElement, boolean toInclusive, int offset, int count);
+
+    Future<Collection<String>> lexRangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count);
+
     Future<Integer> lexCountAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive);
 
     Future<Integer> rankAsync(String o);

src/main/java/org/redisson/core/RScoredSortedSet.java

@@ -61,4 +61,12 @@ public interface RScoredSortedSet<V> extends RScoredSortedSetAsync<V>, Iterable<
 
     Collection<ScoredEntry<V>> entryRange(int startIndex, int endIndex);
 
+    Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
+    Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
+    Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
+    Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
 }

src/main/java/org/redisson/core/RScoredSortedSetAsync.java

@@ -53,4 +53,12 @@ public interface RScoredSortedSetAsync<V> extends RExpirableAsync {
 
     Future<Collection<ScoredEntry<V>>> entryRangeAsync(int startIndex, int endIndex);
 
+    Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
+    Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
+    Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
+    Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
 }

src/test/java/org/redisson/RedissonScoredSortedSetTest.java

@@ -14,6 +14,7 @@ import org.hamcrest.Matchers;
 import org.junit.Assert;
 import org.junit.Test;
 import org.redisson.client.protocol.ScoredEntry;
+import org.redisson.core.RLexSortedSet;
 import org.redisson.core.RScoredSortedSet;
 import org.redisson.core.RSortedSet;
 
@@ -438,6 +439,53 @@ public class RedissonScoredSortedSetTest extends BaseTest {
                 new ScoredEntry<Integer>(50D, 5)));
     }
 
+    @Test
+    public void testLexSortedSet() {
+        RLexSortedSet set = redisson.getLexSortedSet("simple");
+
+        set.add("a");
+        set.add("b");
+        set.add("c");
+        set.add("d");
+        set.add("e");
+
+        Collection<String> r = set.lexRange("b", true, "e", false, 1, 2);
+        String[] a = r.toArray(new String[0]);
+        Assert.assertArrayEquals(new String[]{"c", "d"}, a);
+    }
+
+    @Test
+    public void testScoredSortedSetValueRange() {
+        RScoredSortedSet<String> set = redisson.<String>getScoredSortedSet("simple");
+
+        set.add(0, "a");
+        set.add(1, "b");
+        set.add(2, "c");
+        set.add(3, "d");
+        set.add(4, "e");
+
+        Collection<String> r = set.valueRange(1, true, 4, false, 1, 2);
+        String[] a = r.toArray(new String[0]);
+        Assert.assertArrayEquals(new String[]{"c", "d"}, a);
+    }
+
+    @Test
+    public void testScoredSortedSetEntryRange() {
+        RScoredSortedSet<String> set = redisson.<String>getScoredSortedSet("simple");
+
+        set.add(0, "a");
+        set.add(1, "b");
+        set.add(2, "c");
+        set.add(3, "d");
+        set.add(4, "e");
+
+        Collection<ScoredEntry<String>> r = set.entryRange(1, true, 4, false, 1, 2);
+        ScoredEntry<String>[] a = r.toArray(new ScoredEntry[0]);
+        Assert.assertEquals(2d, a[0].getScore(), 0);
+        Assert.assertEquals(3d, a[1].getScore(), 0);
+        Assert.assertEquals("c", a[0].getValue());
+        Assert.assertEquals("d", a[1].getValue());
+    }
 
     @Test
     public void testAddAndGet() throws InterruptedException {