From 423910bff4758cefbb6c39d2aba917cd28c33454 Mon Sep 17 00:00:00 2001 From: Pepe Lu Date: Wed, 29 Aug 2018 17:43:57 +0800 Subject: [PATCH 1/3] Support sort alpha for list,set,sorted set. #1607 --- .../main/java/org/redisson/RedissonList.java | 46 +++--- .../redisson/RedissonListMultimapValues.java | 11 ++ .../org/redisson/RedissonScoredSortedSet.java | 34 +++-- .../main/java/org/redisson/RedissonSet.java | 35 +++-- .../redisson/RedissonSetMultimapValues.java | 15 +- .../main/java/org/redisson/api/RSortable.java | 17 ++- .../java/org/redisson/api/RSortableAsync.java | 16 ++- .../transaction/BaseTransactionalSet.java | 13 +- .../transaction/RedissonTransactionalSet.java | 12 +- .../java/org/redisson/RedissonListTest.java | 135 ++++++++++++++++-- .../redisson/RedissonScoredSortedSetTest.java | 132 ++++++++++++++++- .../java/org/redisson/RedissonSetTest.java | 133 ++++++++++++++++- 12 files changed, 517 insertions(+), 82 deletions(-) diff --git a/redisson/src/main/java/org/redisson/RedissonList.java b/redisson/src/main/java/org/redisson/RedissonList.java index 2e69a7422..799700321 100644 --- a/redisson/src/main/java/org/redisson/RedissonList.java +++ b/redisson/src/main/java/org/redisson/RedissonList.java @@ -24,18 +24,9 @@ import static org.redisson.client.protocol.RedisCommands.LRANGE; import static org.redisson.client.protocol.RedisCommands.LREM_SINGLE; import static org.redisson.client.protocol.RedisCommands.RPUSH_BOOLEAN; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; -import java.util.ListIterator; -import java.util.NoSuchElementException; - -import org.redisson.api.RFuture; -import org.redisson.api.RList; -import org.redisson.api.RedissonClient; -import org.redisson.api.SortOrder; +import java.util.*; + +import org.redisson.api.*; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisException; import org.redisson.client.codec.Codec; @@ -728,14 +719,24 @@ public class RedissonList extends RedissonExpirable implements RList { public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order) { return readSortAsync(byPattern, getPatterns, order, -1, -1); } - + @Override public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count) { return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count)); } + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + } + @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); + } + + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { List params = new ArrayList(); params.add(getName()); if (byPattern != null) { @@ -751,15 +752,22 @@ public class RedissonList extends RedissonExpirable implements RList { if (count != -1) { params.add(count); } - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } } - params.add(order); - + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, params.toArray()); } - + @Override public int sortTo(String destName, SortOrder order) { return get(sortToAsync(destName, order)); diff --git a/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java index c02a6ac5c..6291c9a41 100644 --- a/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java @@ -741,12 +741,23 @@ public class RedissonListMultimapValues extends RedissonExpirable implements return list.readSort(byPattern, getPatterns, order, offset, count); } + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return list.readSort(byPattern, getPatterns, order, offset, count, alpha); + } + @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { return list.readSortAsync(byPattern, getPatterns, order, offset, count); } + + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return list.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + } + @Override public int sortTo(String destName, SortOrder order) { return list.sortTo(destName, order); diff --git a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java index 7f8a51890..eb9618925 100644 --- a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java +++ b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java @@ -27,10 +27,7 @@ import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.redisson.api.RFuture; -import org.redisson.api.RScoredSortedSet; -import org.redisson.api.RedissonClient; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; @@ -887,8 +884,18 @@ public class RedissonScoredSortedSet extends RedissonExpirable implements RSc return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count)); } + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + } + @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); + } + + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { List params = new ArrayList(); params.add(getName()); if (byPattern != null) { @@ -904,15 +911,22 @@ public class RedissonScoredSortedSet extends RedissonExpirable implements RSc if (count != -1) { params.add(count); } - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } } - params.add(order); - + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); } - + @Override public int sortTo(String destName, SortOrder order) { return get(sortToAsync(destName, order)); diff --git a/redisson/src/main/java/org/redisson/RedissonSet.java b/redisson/src/main/java/org/redisson/RedissonSet.java index 345d6872d..9747ab26f 100644 --- a/redisson/src/main/java/org/redisson/RedissonSet.java +++ b/redisson/src/main/java/org/redisson/RedissonSet.java @@ -23,11 +23,7 @@ import java.util.Iterator; import java.util.List; import java.util.Set; -import org.redisson.api.RFuture; -import org.redisson.api.RLock; -import org.redisson.api.RSet; -import org.redisson.api.RedissonClient; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; @@ -444,8 +440,18 @@ public class RedissonSet extends RedissonExpirable implements RSet, ScanIt return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count)); } + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + } + @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); + } + + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { List params = new ArrayList(); params.add(getName()); if (byPattern != null) { @@ -461,15 +467,22 @@ public class RedissonSet extends RedissonExpirable implements RSet, ScanIt if (count != -1) { params.add(count); } - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } } - params.add(order); - + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); } - + @Override public int sortTo(String destName, SortOrder order) { return get(sortToAsync(destName, order)); diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java index 1e02cd348..012e451c8 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java @@ -23,10 +23,7 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.redisson.api.RFuture; -import org.redisson.api.RLock; -import org.redisson.api.RSet; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; @@ -602,12 +599,22 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R return set.readSort(byPattern, getPatterns, order, offset, count); } + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return set.readSort(byPattern, getPatterns, order, offset, count, alpha); + } + @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { return set.readSortAsync(byPattern, getPatterns, order, offset, count); } + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return set.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + } + @Override public int sortTo(String destName, SortOrder order) { return set.sortTo(destName, order); diff --git a/redisson/src/main/java/org/redisson/api/RSortable.java b/redisson/src/main/java/org/redisson/api/RSortable.java index c1d560c3e..c50481df6 100644 --- a/redisson/src/main/java/org/redisson/api/RSortable.java +++ b/redisson/src/main/java/org/redisson/api/RSortable.java @@ -87,7 +87,21 @@ public interface RSortable extends RSortableAsync { * @return sorted collection */ Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count); - + + /** + * Read data in sorted view + * + * @param object type + * @param byPattern that is used to generate the keys that are used for sorting + * @param getPatterns that is used to load values by keys in sorted view + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @param alpha that indicates whether to sort + * @return sorted collection + */ + Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha); + /** * Sort data and store to destName list * @@ -153,5 +167,4 @@ public interface RSortable extends RSortableAsync { * @return length of sorted data */ int sortTo(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count); - } diff --git a/redisson/src/main/java/org/redisson/api/RSortableAsync.java b/redisson/src/main/java/org/redisson/api/RSortableAsync.java index 84cf3b058..6e61390aa 100644 --- a/redisson/src/main/java/org/redisson/api/RSortableAsync.java +++ b/redisson/src/main/java/org/redisson/api/RSortableAsync.java @@ -15,6 +15,7 @@ */ package org.redisson.api; +import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -88,6 +89,20 @@ public interface RSortableAsync { */ RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count); + /** + * Read data in sorted view + * + * @param object type + * @param byPattern that is used to generate the keys that are used for sorting + * @param getPatterns that is used to load values by keys in sorted view + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @param alpha that indicates whether to sort + * @return sorted collection + */ + RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha); + /** * Sort data and store to destName list * @@ -153,5 +168,4 @@ public interface RSortableAsync { * @return length of sorted data */ RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count); - } diff --git a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java index e57b73257..7817434a7 100644 --- a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java @@ -28,12 +28,7 @@ import java.util.concurrent.TimeUnit; import org.redisson.RedissonMultiLock; import org.redisson.RedissonObject; import org.redisson.RedissonSet; -import org.redisson.api.RCollectionAsync; -import org.redisson.api.RFuture; -import org.redisson.api.RLock; -import org.redisson.api.RObject; -import org.redisson.api.RSet; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.client.RedisClient; import org.redisson.client.protocol.decoder.ListScanResult; import org.redisson.command.CommandAsyncExecutor; @@ -498,7 +493,11 @@ public abstract class BaseTransactionalSet extends BaseTransactionalObject { public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { throw new UnsupportedOperationException(); } - + + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + throw new UnsupportedOperationException(); + } + public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) { throw new UnsupportedOperationException(); } diff --git a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java index 870dc9438..e5f3326b1 100644 --- a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java @@ -15,10 +15,7 @@ */ package org.redisson.transaction; -import java.util.Collection; -import java.util.Date; -import java.util.List; -import java.util.Set; +import java.util.*; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; @@ -202,7 +199,12 @@ public class RedissonTransactionalSet extends RedissonSet { checkState(); return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count); } - + + @Override + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + } + @Override public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) { checkState(); diff --git a/redisson/src/test/java/org/redisson/RedissonListTest.java b/redisson/src/test/java/org/redisson/RedissonListTest.java index de016ede5..7425dde11 100644 --- a/redisson/src/test/java/org/redisson/RedissonListTest.java +++ b/redisson/src/test/java/org/redisson/RedissonListTest.java @@ -2,18 +2,12 @@ package org.redisson; import static org.assertj.core.api.Assertions.assertThat; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; -import java.util.ListIterator; +import java.util.*; import org.junit.Assert; import org.junit.Test; import org.redisson.api.RList; +import org.redisson.api.RSortableAsync; import org.redisson.api.SortOrder; import org.redisson.client.RedisException; import org.redisson.client.codec.IntegerCodec; @@ -141,7 +135,130 @@ public class RedissonListTest extends BaseTest { Collection ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2); assertThat(ascSort).containsExactly("obj2", "obj3"); } - + + @Test + public void testSortAlpha(){ + RList list = redisson.getList("list", StringCodec.INSTANCE); + list.add("1"); + list.add("3"); + list.add("12"); + + assertThat(list.readSort(null, null, SortOrder.ASC, -1, -1, true)) + .containsExactly("1", "12", "3"); + } + + @Test + public void testSortOrderAlpha(){ + RList list = redisson.getList("list", StringCodec.INSTANCE); + list.add("1"); + list.add("3"); + list.add("12"); + + assertThat(list.readSort(null, null, SortOrder.DESC, -1, -1, true)) + .containsExactly("3", "12", "1"); + } + + @Test + public void testSortOrderLimitAlpha(){ + RList list = redisson.getList("list", StringCodec.INSTANCE); + list.add("1"); + list.add("3"); + list.add("12"); + + assertThat(list.readSort(null, null, SortOrder.DESC, 0, 2, true)) + .containsExactly("3", "12"); + assertThat(list.readSort(null, null, SortOrder.DESC, 1, 2, true)) + .containsExactly("12", "1"); + } + + @Test + public void testSortOrderByPatternAlpha(){ + RList list = redisson.getList("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = list + .readSort("test*", null, SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly(2, 1, 3); + + Collection ascSort = list + .readSort("test*", null, SortOrder.ASC, -1, -1, true); + assertThat(ascSort).containsExactly(3, 1, 2); + } + + @Test + public void testSortOrderByPatternAlphaLimit(){ + RList list = redisson.getList("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = list + .readSort("test*", null, SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly(1, 3); + + Collection ascSort = list + .readSort("test*", null, SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly(1, 2); + } + + @Test + public void testSortOrderByPatternGetAlpha() { + RList list = redisson.getList("list", StringCodec.INSTANCE); + list.add("1"); + list.add("2"); + list.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = list + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); + + Collection ascSort = list + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); + } + + @Test + public void testSortOrderByPatternGetAlphaLimit() { + RList list = redisson.getList("list", StringCodec.INSTANCE); + list.add("1"); + list.add("2"); + list.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = list + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly("obj1", "obj3"); + + Collection ascSort = list + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly("obj1", "obj2"); + } + @Test public void testSortTo() { RList list = redisson.getList("list", IntegerCodec.INSTANCE); diff --git a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java index ff7c6abdb..097f85b94 100644 --- a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java @@ -18,12 +18,7 @@ import java.util.concurrent.TimeUnit; import org.junit.Assert; import org.junit.Assume; import org.junit.Test; -import org.redisson.api.RFuture; -import org.redisson.api.RLexSortedSet; -import org.redisson.api.RList; -import org.redisson.api.RScoredSortedSet; -import org.redisson.api.RSortedSet; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.client.codec.IntegerCodec; import org.redisson.client.codec.StringCodec; import org.redisson.client.protocol.ScoredEntry; @@ -173,7 +168,130 @@ public class RedissonScoredSortedSetTest extends BaseTest { Collection ascSort = set.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2); assertThat(ascSort).containsExactly("obj2", "obj3"); } - + + @Test + public void testSortAlpha(){ + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,1); + set.add(9,3); + set.add(8,12); + + assertThat(set.readSort(null, null, SortOrder.ASC, -1, -1, true)) + .containsExactly("1", "12", "3"); + } + + @Test + public void testSortOrderAlpha(){ + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,1); + set.add(9,3); + set.add(8,12); + + assertThat(set.readSort(null, null, SortOrder.DESC, -1, -1, true)) + .containsExactly("3", "12", "1"); + } + + @Test + public void testSortOrderLimitAlpha(){ + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,1); + set.add(9,3); + set.add(8,12); + + assertThat(set.readSort(null, null, SortOrder.DESC, 0, 2, true)) + .containsExactly("3", "12"); + assertThat(set.readSort(null, null, SortOrder.DESC, 1, 2, true)) + .containsExactly("12", "1"); + } + + @Test + public void testSortOrderByPatternAlpha(){ + RScoredSortedSet set = redisson.getScoredSortedSet("list", IntegerCodec.INSTANCE); + set.add(10,1); + set.add(9,2); + set.add(8,3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = set + .readSort("test*", null, SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly(2, 1, 3); + + Collection ascSort = set + .readSort("test*", null, SortOrder.ASC, -1, -1, true); + assertThat(ascSort).containsExactly(3, 1, 2); + } + + @Test + public void testSortOrderByPatternAlphaLimit(){ + RScoredSortedSet set = redisson.getScoredSortedSet("list", IntegerCodec.INSTANCE); + set.add(10,1); + set.add(9, 2); + set.add(8, 3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = set + .readSort("test*", null, SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly(1, 3); + + Collection ascSort = set + .readSort("test*", null, SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly(1, 2); + } + + @Test + public void testSortOrderByPatternGetAlpha() { + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,1); + set.add(9, 2); + set.add(8, 3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); + + Collection ascSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); + } + + @Test + public void testSortOrderByPatternGetAlphaLimit() { + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,1); + set.add(9, 2); + set.add(8, 3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly("obj1", "obj3"); + + Collection ascSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly("obj1", "obj2"); + } + @Test public void testSortTo() { RScoredSortedSet set = redisson.getScoredSortedSet("list", IntegerCodec.INSTANCE); diff --git a/redisson/src/test/java/org/redisson/RedissonSetTest.java b/redisson/src/test/java/org/redisson/RedissonSetTest.java index bc388f909..c1355346d 100644 --- a/redisson/src/test/java/org/redisson/RedissonSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonSetTest.java @@ -16,11 +16,7 @@ import org.junit.Assert; import org.junit.Test; import org.redisson.ClusterRunner.ClusterProcesses; import org.redisson.RedisRunner.FailedToStartRedisException; -import org.redisson.api.RFuture; -import org.redisson.api.RList; -import org.redisson.api.RSet; -import org.redisson.api.RedissonClient; -import org.redisson.api.SortOrder; +import org.redisson.api.*; import org.redisson.client.codec.IntegerCodec; import org.redisson.client.codec.StringCodec; import org.redisson.config.Config; @@ -149,14 +145,137 @@ public class RedissonSetTest extends BaseTest { Collection ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2); assertThat(ascSort).containsExactly("obj2", "obj3"); } - + + @Test + public void testSortAlpha(){ + RSet set = redisson.getSet("list", StringCodec.INSTANCE); + set.add("1"); + set.add("3"); + set.add("12"); + + assertThat(set.readSort(null, null, SortOrder.ASC, -1, -1, true)) + .containsExactly("1", "12", "3"); + } + + @Test + public void testSortOrderAlpha(){ + RSet set = redisson.getSet("list", StringCodec.INSTANCE); + set.add("1"); + set.add("3"); + set.add("12"); + + assertThat(set.readSort(null, null, SortOrder.DESC, -1, -1, true)) + .containsExactly("3", "12", "1"); + } + + @Test + public void testSortOrderLimitAlpha(){ + RSet set = redisson.getSet("list", StringCodec.INSTANCE); + set.add("1"); + set.add("3"); + set.add("12"); + + assertThat(set.readSort(null, null, SortOrder.DESC, 0, 2, true)) + .containsExactly("3", "12"); + assertThat(set.readSort(null, null, SortOrder.DESC, 1, 2, true)) + .containsExactly("12", "1"); + } + + @Test + public void testSortOrderByPatternAlpha(){ + RSet set = redisson.getSet("list", IntegerCodec.INSTANCE); + set.add(1); + set.add(2); + set.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = set + .readSort("test*", null, SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly(2, 1, 3); + + Collection ascSort = set + .readSort("test*", null, SortOrder.ASC, -1, -1, true); + assertThat(ascSort).containsExactly(3, 1, 2); + } + + @Test + public void testSortOrderByPatternAlphaLimit(){ + RSet set = redisson.getSet("list", IntegerCodec.INSTANCE); + set.add(1); + set.add(2); + set.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Collection descSort = set + .readSort("test*", null, SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly(1, 3); + + Collection ascSort = set + .readSort("test*", null, SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly(1, 2); + } + + @Test + public void testSortOrderByPatternGetAlpha() { + RSet set = redisson.getSet("list", StringCodec.INSTANCE); + set.add("1"); + set.add("2"); + set.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); + + Collection ascSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); + } + + @Test + public void testSortOrderByPatternGetAlphaLimit() { + RSet set = redisson.getSet("list", StringCodec.INSTANCE); + set.add("1"); + set.add("2"); + set.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(12); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1"); + redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2"); + redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); + + Collection descSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + assertThat(descSort).containsExactly("obj1", "obj3"); + + Collection ascSort = set + .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + assertThat(ascSort).containsExactly("obj1", "obj2"); + } + @Test public void testSortTo() { RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); list.add("1"); list.add("2"); list.add("3"); - + assertThat(list.sortTo("test3", SortOrder.DESC)).isEqualTo(3); RList list2 = redisson.getList("test3", StringCodec.INSTANCE); assertThat(list2).containsExactly("3", "2", "1"); From d1d9f8d7405616dcbcf2ccd3d94594d4e744da28 Mon Sep 17 00:00:00 2001 From: Pepe Lu Date: Fri, 31 Aug 2018 10:27:53 +0800 Subject: [PATCH 2/3] prevent star import --- .../src/main/java/org/redisson/RedissonList.java | 15 ++++++++++++--- .../org/redisson/RedissonScoredSortedSet.java | 5 ++++- .../src/main/java/org/redisson/RedissonSet.java | 6 +++++- .../org/redisson/RedissonSetMultimapValues.java | 5 ++++- .../transaction/BaseTransactionalSet.java | 7 ++++++- .../transaction/RedissonTransactionalSet.java | 5 ++++- .../test/java/org/redisson/RedissonListTest.java | 10 ++++++++-- .../org/redisson/RedissonScoredSortedSetTest.java | 7 ++++++- .../test/java/org/redisson/RedissonSetTest.java | 6 +++++- 9 files changed, 54 insertions(+), 12 deletions(-) diff --git a/redisson/src/main/java/org/redisson/RedissonList.java b/redisson/src/main/java/org/redisson/RedissonList.java index 799700321..5a2b5e587 100644 --- a/redisson/src/main/java/org/redisson/RedissonList.java +++ b/redisson/src/main/java/org/redisson/RedissonList.java @@ -24,9 +24,18 @@ import static org.redisson.client.protocol.RedisCommands.LRANGE; import static org.redisson.client.protocol.RedisCommands.LREM_SINGLE; import static org.redisson.client.protocol.RedisCommands.RPUSH_BOOLEAN; -import java.util.*; - -import org.redisson.api.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.NoSuchElementException; + +import org.redisson.api.RFuture; +import org.redisson.api.RList; +import org.redisson.api.RedissonClient; +import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisException; import org.redisson.client.codec.Codec; diff --git a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java index eb9618925..823920e94 100644 --- a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java +++ b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java @@ -27,7 +27,10 @@ import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.redisson.api.*; +import org.redisson.api.RFuture; +import org.redisson.api.RScoredSortedSet; +import org.redisson.api.RedissonClient; +import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; diff --git a/redisson/src/main/java/org/redisson/RedissonSet.java b/redisson/src/main/java/org/redisson/RedissonSet.java index 9747ab26f..0730983cc 100644 --- a/redisson/src/main/java/org/redisson/RedissonSet.java +++ b/redisson/src/main/java/org/redisson/RedissonSet.java @@ -23,7 +23,11 @@ import java.util.Iterator; import java.util.List; import java.util.Set; -import org.redisson.api.*; +import org.redisson.api.RFuture; +import org.redisson.api.RLock; +import org.redisson.api.RSet; +import org.redisson.api.RedissonClient; +import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java index 012e451c8..14c5a3620 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java @@ -23,7 +23,10 @@ import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; -import org.redisson.api.*; +import org.redisson.api.RFuture; +import org.redisson.api.RLock; +import org.redisson.api.RSet; +import org.redisson.api.SortOrder; import org.redisson.api.mapreduce.RCollectionMapReduce; import org.redisson.client.RedisClient; import org.redisson.client.codec.Codec; diff --git a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java index 7817434a7..ab8201c22 100644 --- a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java @@ -28,7 +28,12 @@ import java.util.concurrent.TimeUnit; import org.redisson.RedissonMultiLock; import org.redisson.RedissonObject; import org.redisson.RedissonSet; -import org.redisson.api.*; +import org.redisson.api.RCollectionAsync; +import org.redisson.api.RFuture; +import org.redisson.api.RLock; +import org.redisson.api.RObject; +import org.redisson.api.RSet; +import org.redisson.api.SortOrder; import org.redisson.client.RedisClient; import org.redisson.client.protocol.decoder.ListScanResult; import org.redisson.command.CommandAsyncExecutor; diff --git a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java index e5f3326b1..1dd666a80 100644 --- a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java @@ -15,7 +15,10 @@ */ package org.redisson.transaction; -import java.util.*; +import java.util.Collection; +import java.util.Date; +import java.util.List; +import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; diff --git a/redisson/src/test/java/org/redisson/RedissonListTest.java b/redisson/src/test/java/org/redisson/RedissonListTest.java index 7425dde11..86d14c1c8 100644 --- a/redisson/src/test/java/org/redisson/RedissonListTest.java +++ b/redisson/src/test/java/org/redisson/RedissonListTest.java @@ -2,12 +2,18 @@ package org.redisson; import static org.assertj.core.api.Assertions.assertThat; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; import org.junit.Assert; import org.junit.Test; import org.redisson.api.RList; -import org.redisson.api.RSortableAsync; import org.redisson.api.SortOrder; import org.redisson.client.RedisException; import org.redisson.client.codec.IntegerCodec; diff --git a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java index 097f85b94..269ca40bc 100644 --- a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java @@ -18,7 +18,12 @@ import java.util.concurrent.TimeUnit; import org.junit.Assert; import org.junit.Assume; import org.junit.Test; -import org.redisson.api.*; +import org.redisson.api.RFuture; +import org.redisson.api.RLexSortedSet; +import org.redisson.api.RList; +import org.redisson.api.RScoredSortedSet; +import org.redisson.api.RSortedSet; +import org.redisson.api.SortOrder; import org.redisson.client.codec.IntegerCodec; import org.redisson.client.codec.StringCodec; import org.redisson.client.protocol.ScoredEntry; diff --git a/redisson/src/test/java/org/redisson/RedissonSetTest.java b/redisson/src/test/java/org/redisson/RedissonSetTest.java index c1355346d..63962f6eb 100644 --- a/redisson/src/test/java/org/redisson/RedissonSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonSetTest.java @@ -16,7 +16,11 @@ import org.junit.Assert; import org.junit.Test; import org.redisson.ClusterRunner.ClusterProcesses; import org.redisson.RedisRunner.FailedToStartRedisException; -import org.redisson.api.*; +import org.redisson.api.RFuture; +import org.redisson.api.RList; +import org.redisson.api.RSet; +import org.redisson.api.RedissonClient; +import org.redisson.api.SortOrder; import org.redisson.client.codec.IntegerCodec; import org.redisson.client.codec.StringCodec; import org.redisson.config.Config; From f86865e2608b5ceef6fb3a9da9cca1ccc7f2be13 Mon Sep 17 00:00:00 2001 From: Pepe Lu Date: Mon, 3 Sep 2018 15:41:39 +0800 Subject: [PATCH 3/3] refactor sort alpha api --- .../main/java/org/redisson/RedissonList.java | 120 ++++++++++++----- .../redisson/RedissonListMultimapValues.java | 63 ++++++++- .../org/redisson/RedissonScoredSortedSet.java | 121 +++++++++++++----- .../main/java/org/redisson/RedissonSet.java | 121 +++++++++++++----- .../redisson/RedissonSetMultimapValues.java | 64 ++++++++- .../main/java/org/redisson/api/RSortable.java | 57 ++++++++- .../java/org/redisson/api/RSortableAsync.java | 58 ++++++++- .../transaction/BaseTransactionalSet.java | 24 +++- .../transaction/RedissonTransactionalSet.java | 29 ++++- .../java/org/redisson/RedissonListTest.java | 35 ++--- .../redisson/RedissonScoredSortedSetTest.java | 51 +++----- .../java/org/redisson/RedissonSetTest.java | 35 ++--- 12 files changed, 576 insertions(+), 202 deletions(-) diff --git a/redisson/src/main/java/org/redisson/RedissonList.java b/redisson/src/main/java/org/redisson/RedissonList.java index 5a2b5e587..f0bf84810 100644 --- a/redisson/src/main/java/org/redisson/RedissonList.java +++ b/redisson/src/main/java/org/redisson/RedissonList.java @@ -735,46 +735,68 @@ public class RedissonList extends RedissonExpirable implements RList { } @Override - public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { - return readSortAsync(byPattern, getPatterns, order, offset, count, false); + public List readSortAlpha(SortOrder order) { + return get(readSortAlphaAsync(order)); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - List params = new ArrayList(); - params.add(getName()); - if (byPattern != null) { - params.add("BY"); - params.add(byPattern); - } - if (offset != -1 && count != -1) { - params.add("LIMIT"); - } - if (offset != -1) { - params.add(offset); - } - if (count != -1) { - params.add(count); - } - if (getPatterns != null) { - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); - } - } - if (alpha) { - params.add("ALPHA"); - } - if (order != null) { - params.add(order); - } + public RFuture> readSortAlphaAsync(SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "ALPHA", order); + } - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, params.toArray()); + @Override + public List readSortAlpha(SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(order, offset, count)); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public List readSortAlpha(String byPattern, SortOrder order) { + return get(readSortAlphaAsync(byPattern, order)); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, "ALPHA", order); + } + + @Override + public List readSortAlpha(String byPattern, SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(byPattern, order, offset, count)); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order)); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count)); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, true); } @Override @@ -860,4 +882,36 @@ public class RedissonList extends RedissonExpirable implements RList { return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); } + private RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + List params = new ArrayList(); + params.add(getName()); + if (byPattern != null) { + params.add("BY"); + params.add(byPattern); + } + if (offset != -1 && count != -1) { + params.add("LIMIT"); + } + if (offset != -1) { + params.add(offset); + } + if (count != -1) { + params.add(count); + } + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } + } + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, params.toArray()); + } + } diff --git a/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java index 6291c9a41..99385564c 100644 --- a/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonListMultimapValues.java @@ -741,21 +741,70 @@ public class RedissonListMultimapValues extends RedissonExpirable implements return list.readSort(byPattern, getPatterns, order, offset, count); } - @Override - public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return list.readSort(byPattern, getPatterns, order, offset, count, alpha); - } - @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { return list.readSortAsync(byPattern, getPatterns, order, offset, count); } + @Override + public List readSortAlpha(SortOrder order) { + return list.readSortAlpha(order); + } + + @Override + public List readSortAlpha(SortOrder order, int offset, int count) { + return list.readSortAlpha(order, offset, count); + } + + @Override + public List readSortAlpha(String byPattern, SortOrder order) { + return list.readSortAlpha(byPattern, order); + } + + @Override + public List readSortAlpha(String byPattern, SortOrder order, int offset, int count) { + return list.readSortAlpha(byPattern, order, offset, count); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) { + return list.readSortAlpha(byPattern, getPatterns, order); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return list.readSortAlpha(byPattern, getPatterns, order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order) { + return list.readSortAlphaAsync(order); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return list.readSortAlphaAsync(order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return list.readSortAlphaAsync(byPattern, order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return list.readSortAlphaAsync(byPattern, order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return list.readSortAlphaAsync(byPattern, getPatterns, order); + } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return list.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return list.readSortAlphaAsync(byPattern, getPatterns, order, offset, count); } @Override diff --git a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java index 823920e94..68c4f58bf 100644 --- a/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java +++ b/redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java @@ -888,46 +888,68 @@ public class RedissonScoredSortedSet extends RedissonExpirable implements RSc } @Override - public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { - return readSortAsync(byPattern, getPatterns, order, offset, count, false); + public Set readSortAlpha(SortOrder order) { + return get(readSortAlphaAsync(order)); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - List params = new ArrayList(); - params.add(getName()); - if (byPattern != null) { - params.add("BY"); - params.add(byPattern); - } - if (offset != -1 && count != -1) { - params.add("LIMIT"); - } - if (offset != -1) { - params.add(offset); - } - if (count != -1) { - params.add(count); - } - if (getPatterns != null) { - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); - } - } - if (alpha) { - params.add("ALPHA"); - } - if (order != null) { - params.add(order); - } + public Set readSortAlpha(SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(order, offset, count)); + } - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); + @Override + public Set readSortAlpha(String byPattern, SortOrder order) { + return get(readSortAlphaAsync(byPattern, order)); + } + + @Override + public Set readSortAlpha(String byPattern, SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(byPattern, order, offset, count)); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order)); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count)); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, true); } @Override @@ -1012,5 +1034,36 @@ public class RedissonScoredSortedSet extends RedissonExpirable implements RSc return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); } - + + private RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + List params = new ArrayList(); + params.add(getName()); + if (byPattern != null) { + params.add("BY"); + params.add(byPattern); + } + if (offset != -1 && count != -1) { + params.add("LIMIT"); + } + if (offset != -1) { + params.add(offset); + } + if (count != -1) { + params.add(count); + } + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } + } + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); + } } diff --git a/redisson/src/main/java/org/redisson/RedissonSet.java b/redisson/src/main/java/org/redisson/RedissonSet.java index 0730983cc..aa7521a19 100644 --- a/redisson/src/main/java/org/redisson/RedissonSet.java +++ b/redisson/src/main/java/org/redisson/RedissonSet.java @@ -445,46 +445,68 @@ public class RedissonSet extends RedissonExpirable implements RSet, ScanIt } @Override - public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return (Collection)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha)); + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, false); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { - return readSortAsync(byPattern, getPatterns, order, offset, count, false); + public Set readSortAlpha(SortOrder order) { + return get(readSortAlphaAsync(order)); } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - List params = new ArrayList(); - params.add(getName()); - if (byPattern != null) { - params.add("BY"); - params.add(byPattern); - } - if (offset != -1 && count != -1) { - params.add("LIMIT"); - } - if (offset != -1) { - params.add(offset); - } - if (count != -1) { - params.add(count); - } - if (getPatterns != null) { - for (String pattern : getPatterns) { - params.add("GET"); - params.add(pattern); - } - } - if (alpha) { - params.add("ALPHA"); - } - if (order != null) { - params.add(order); - } + public Set readSortAlpha(SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(order, offset, count)); + } - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); + @Override + public Set readSortAlpha(String byPattern, SortOrder order) { + return get(readSortAlphaAsync(byPattern, order)); + } + + @Override + public Set readSortAlpha(String byPattern, SortOrder order, int offset, int count) { + return get(readSortAlphaAsync(byPattern, order, offset, count)); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order)); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return (Collection)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count)); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "LIMIT", offset, count, "ALPHA", order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return readSortAsync(byPattern, getPatterns, order, offset, count, true); } @Override @@ -594,5 +616,36 @@ public class RedissonSet extends RedissonExpirable implements RSet, ScanIt return commandExecutor.readAsync(client, name, codec, RedisCommands.SSCAN, name, startPos, "MATCH", pattern, "COUNT", count); } - + + private RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + List params = new ArrayList(); + params.add(getName()); + if (byPattern != null) { + params.add("BY"); + params.add(byPattern); + } + if (offset != -1 && count != -1) { + params.add("LIMIT"); + } + if (offset != -1) { + params.add(offset); + } + if (count != -1) { + params.add(count); + } + if (getPatterns != null) { + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } + } + if (alpha) { + params.add("ALPHA"); + } + if (order != null) { + params.add(order); + } + + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray()); + } } diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java index 14c5a3620..0a24fec95 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java @@ -602,11 +602,6 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R return set.readSort(byPattern, getPatterns, order, offset, count); } - @Override - public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return set.readSort(byPattern, getPatterns, order, offset, count, alpha); - } - @Override public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { @@ -614,8 +609,63 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return set.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + public Set readSortAlpha(SortOrder order) { + return set.readSortAlpha(order); + } + + @Override + public Set readSortAlpha(SortOrder order, int offset, int count) { + return set.readSortAlpha(order, offset, count); + } + + @Override + public Set readSortAlpha(String byPattern, SortOrder order) { + return set.readSortAlpha(byPattern, order); + } + + @Override + public Set readSortAlpha(String byPattern, SortOrder order, int offset, int count) { + return set.readSortAlpha(byPattern, order, offset, count); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order) { + return set.readSortAlpha(byPattern, getPatterns, order); + } + + @Override + public Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return set.readSortAlpha(byPattern, getPatterns, order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order) { + return set.readSortAlphaAsync(order); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return set.readSortAlphaAsync(order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return set.readSortAlphaAsync(byPattern, order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return set.readSortAlphaAsync(byPattern, order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return set.readSortAlphaAsync(byPattern, getPatterns, order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return set.readSortAlphaAsync(byPattern, getPatterns, order, offset, count); } @Override diff --git a/redisson/src/main/java/org/redisson/api/RSortable.java b/redisson/src/main/java/org/redisson/api/RSortable.java index c50481df6..362f88ba3 100644 --- a/redisson/src/main/java/org/redisson/api/RSortable.java +++ b/redisson/src/main/java/org/redisson/api/RSortable.java @@ -89,7 +89,56 @@ public interface RSortable extends RSortableAsync { Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count); /** - * Read data in sorted view + * Read data in sorted view lexicographically + * + * @param order for sorted data + * @return sorted collection lexicographically + */ + V readSortAlpha(SortOrder order); + + /** + * Read data in sorted view lexicographically + * + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @return sorted collection lexicographically + */ + V readSortAlpha(SortOrder order, int offset, int count); + + /** + * Read data in sorted view lexicographically + * + * @param byPattern that is used to generate the keys that are used for sorting + * @param order for sorted data + * @return sorted collection lexicographically + */ + V readSortAlpha(String byPattern, SortOrder order); + + /** + * Read data in sorted view lexicographically + * + * @param byPattern that is used to generate the keys that are used for sorting + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @return sorted collection lexicographically + */ + V readSortAlpha(String byPattern, SortOrder order, int offset, int count); + + /** + * Read data in sorted view lexicographically + * + * @param object type + * @param byPattern that is used to generate the keys that are used for sorting + * @param getPatterns that is used to load values by keys in sorted view + * @param order for sorted data + * @return sorted collection lexicographically + */ + Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order); + + /** + * Read data in sorted view lexicographically * * @param object type * @param byPattern that is used to generate the keys that are used for sorting @@ -97,10 +146,9 @@ public interface RSortable extends RSortableAsync { * @param order for sorted data * @param offset of sorted data * @param count of sorted data - * @param alpha that indicates whether to sort - * @return sorted collection + * @return sorted collection lexicographically */ - Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha); + Collection readSortAlpha(String byPattern, List getPatterns, SortOrder order, int offset, int count); /** * Sort data and store to destName list @@ -167,4 +215,5 @@ public interface RSortable extends RSortableAsync { * @return length of sorted data */ int sortTo(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count); + } diff --git a/redisson/src/main/java/org/redisson/api/RSortableAsync.java b/redisson/src/main/java/org/redisson/api/RSortableAsync.java index 6e61390aa..dad3058e4 100644 --- a/redisson/src/main/java/org/redisson/api/RSortableAsync.java +++ b/redisson/src/main/java/org/redisson/api/RSortableAsync.java @@ -15,7 +15,6 @@ */ package org.redisson.api; -import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -90,7 +89,56 @@ public interface RSortableAsync { RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count); /** - * Read data in sorted view + * Read data in sorted view lexicographically + * + * @param order for sorted data + * @return sorted collection lexicographically + */ + RFuture readSortAlphaAsync(SortOrder order); + + /** + * Read data in sorted view lexicographically + * + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @return sorted collection lexicographically + */ + RFuture readSortAlphaAsync(SortOrder order, int offset, int count); + + /** + * Read data in sorted view lexicographically + * + * @param byPattern that is used to generate the keys that are used for sorting + * @param order for sorted data + * @return sorted collection lexicographically + */ + RFuture readSortAlphaAsync(String byPattern, SortOrder order); + + /** + * Read data in sorted view lexicographically + * + * @param byPattern that is used to generate the keys that are used for sorting + * @param order for sorted data + * @param offset of sorted data + * @param count of sorted data + * @return sorted collection lexicographically + */ + RFuture readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count); + + /** + * Read data in sorted view lexicographically + * + * @param object type + * @param byPattern that is used to generate the keys that are used for sorting + * @param getPatterns that is used to load values by keys in sorted view + * @param order for sorted data + * @return sorted collection lexicographically + */ + RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order); + + /** + * Read data in sorted view lexicographically * * @param object type * @param byPattern that is used to generate the keys that are used for sorting @@ -98,10 +146,9 @@ public interface RSortableAsync { * @param order for sorted data * @param offset of sorted data * @param count of sorted data - * @param alpha that indicates whether to sort - * @return sorted collection + * @return sorted collection lexicographically */ - RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha); + RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count); /** * Sort data and store to destName list @@ -168,4 +215,5 @@ public interface RSortableAsync { * @return length of sorted data */ RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count); + } diff --git a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java index ab8201c22..d8f8cdbb5 100644 --- a/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java @@ -494,12 +494,32 @@ public abstract class BaseTransactionalSet extends BaseTransactionalObject { public RFuture> readSortAsync(String byPattern, SortOrder order) { throw new UnsupportedOperationException(); } - + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { throw new UnsupportedOperationException(); } - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { + public RFuture> readSortAlphaAsync(SortOrder order) { + throw new UnsupportedOperationException(); + } + + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + throw new UnsupportedOperationException(); + } + + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + throw new UnsupportedOperationException(); + } + + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + throw new UnsupportedOperationException(); + } + + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + throw new UnsupportedOperationException(); + } + + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { throw new UnsupportedOperationException(); } diff --git a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java index 1dd666a80..25c200e68 100644 --- a/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java +++ b/redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java @@ -204,8 +204,33 @@ public class RedissonTransactionalSet extends RedissonSet { } @Override - public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count, boolean alpha) { - return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count, alpha); + public RFuture> readSortAlphaAsync(SortOrder order) { + return transactionalSet.readSortAlphaAsync(order); + } + + @Override + public RFuture> readSortAlphaAsync(SortOrder order, int offset, int count) { + return transactionalSet.readSortAlphaAsync(order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order) { + return transactionalSet.readSortAlphaAsync(byPattern, order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) { + return transactionalSet.readSortAlphaAsync(byPattern, order, offset, count); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order) { + return transactionalSet.readSortAlphaAsync(byPattern, getPatterns, order); + } + + @Override + public RFuture> readSortAlphaAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return transactionalSet.readSortAlphaAsync(byPattern, getPatterns, order, offset, count); } @Override diff --git a/redisson/src/test/java/org/redisson/RedissonListTest.java b/redisson/src/test/java/org/redisson/RedissonListTest.java index 86d14c1c8..eb3d6cd58 100644 --- a/redisson/src/test/java/org/redisson/RedissonListTest.java +++ b/redisson/src/test/java/org/redisson/RedissonListTest.java @@ -142,17 +142,6 @@ public class RedissonListTest extends BaseTest { assertThat(ascSort).containsExactly("obj2", "obj3"); } - @Test - public void testSortAlpha(){ - RList list = redisson.getList("list", StringCodec.INSTANCE); - list.add("1"); - list.add("3"); - list.add("12"); - - assertThat(list.readSort(null, null, SortOrder.ASC, -1, -1, true)) - .containsExactly("1", "12", "3"); - } - @Test public void testSortOrderAlpha(){ RList list = redisson.getList("list", StringCodec.INSTANCE); @@ -160,7 +149,9 @@ public class RedissonListTest extends BaseTest { list.add("3"); list.add("12"); - assertThat(list.readSort(null, null, SortOrder.DESC, -1, -1, true)) + assertThat(list.readSortAlpha( SortOrder.ASC)) + .containsExactly("1", "12", "3"); + assertThat(list.readSortAlpha( SortOrder.DESC)) .containsExactly("3", "12", "1"); } @@ -171,9 +162,9 @@ public class RedissonListTest extends BaseTest { list.add("3"); list.add("12"); - assertThat(list.readSort(null, null, SortOrder.DESC, 0, 2, true)) + assertThat(list.readSortAlpha(SortOrder.DESC, 0, 2)) .containsExactly("3", "12"); - assertThat(list.readSort(null, null, SortOrder.DESC, 1, 2, true)) + assertThat(list.readSortAlpha(SortOrder.DESC, 1, 2)) .containsExactly("12", "1"); } @@ -189,11 +180,11 @@ public class RedissonListTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = list - .readSort("test*", null, SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", SortOrder.DESC); assertThat(descSort).containsExactly(2, 1, 3); Collection ascSort = list - .readSort("test*", null, SortOrder.ASC, -1, -1, true); + .readSortAlpha("test*", SortOrder.ASC); assertThat(ascSort).containsExactly(3, 1, 2); } @@ -209,11 +200,11 @@ public class RedissonListTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = list - .readSort("test*", null, SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", SortOrder.DESC,1, 2); assertThat(descSort).containsExactly(1, 3); Collection ascSort = list - .readSort("test*", null, SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", SortOrder.ASC,1, 2); assertThat(ascSort).containsExactly(1, 2); } @@ -233,11 +224,11 @@ public class RedissonListTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = list - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC); assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); Collection ascSort = list - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC); assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); } @@ -257,11 +248,11 @@ public class RedissonListTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = list - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2); assertThat(descSort).containsExactly("obj1", "obj3"); Collection ascSort = list - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2); assertThat(ascSort).containsExactly("obj1", "obj2"); } diff --git a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java index 269ca40bc..2cbcd1403 100644 --- a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java @@ -174,38 +174,29 @@ public class RedissonScoredSortedSetTest extends BaseTest { assertThat(ascSort).containsExactly("obj2", "obj3"); } - @Test - public void testSortAlpha(){ - RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); - set.add(10,1); - set.add(9,3); - set.add(8,12); - - assertThat(set.readSort(null, null, SortOrder.ASC, -1, -1, true)) - .containsExactly("1", "12", "3"); - } - @Test public void testSortOrderAlpha(){ - RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); - set.add(10,1); - set.add(9,3); - set.add(8,12); + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,"1"); + set.add(9,"3"); + set.add(8,"12"); - assertThat(set.readSort(null, null, SortOrder.DESC, -1, -1, true)) + assertThat(set.readSortAlpha(SortOrder.ASC)) + .containsExactly("1", "12", "3"); + assertThat(set.readSortAlpha(SortOrder.DESC)) .containsExactly("3", "12", "1"); } @Test public void testSortOrderLimitAlpha(){ - RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); - set.add(10,1); - set.add(9,3); - set.add(8,12); + RScoredSortedSet set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE); + set.add(10,"1"); + set.add(9,"3"); + set.add(8,"12"); - assertThat(set.readSort(null, null, SortOrder.DESC, 0, 2, true)) + assertThat(set.readSortAlpha(SortOrder.DESC, 0, 2)) .containsExactly("3", "12"); - assertThat(set.readSort(null, null, SortOrder.DESC, 1, 2, true)) + assertThat(set.readSortAlpha(SortOrder.DESC, 1, 2)) .containsExactly("12", "1"); } @@ -221,11 +212,11 @@ public class RedissonScoredSortedSetTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = set - .readSort("test*", null, SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", SortOrder.DESC); assertThat(descSort).containsExactly(2, 1, 3); Collection ascSort = set - .readSort("test*", null, SortOrder.ASC, -1, -1, true); + .readSortAlpha("test*", SortOrder.ASC); assertThat(ascSort).containsExactly(3, 1, 2); } @@ -241,11 +232,11 @@ public class RedissonScoredSortedSetTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = set - .readSort("test*", null, SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", SortOrder.DESC,1,2); assertThat(descSort).containsExactly(1, 3); Collection ascSort = set - .readSort("test*", null, SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", SortOrder.ASC,1,2); assertThat(ascSort).containsExactly(1, 2); } @@ -265,11 +256,11 @@ public class RedissonScoredSortedSetTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC); assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); Collection ascSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC); assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); } @@ -289,11 +280,11 @@ public class RedissonScoredSortedSetTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1,2); assertThat(descSort).containsExactly("obj1", "obj3"); Collection ascSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2); assertThat(ascSort).containsExactly("obj1", "obj2"); } diff --git a/redisson/src/test/java/org/redisson/RedissonSetTest.java b/redisson/src/test/java/org/redisson/RedissonSetTest.java index 63962f6eb..3da84b182 100644 --- a/redisson/src/test/java/org/redisson/RedissonSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonSetTest.java @@ -150,17 +150,6 @@ public class RedissonSetTest extends BaseTest { assertThat(ascSort).containsExactly("obj2", "obj3"); } - @Test - public void testSortAlpha(){ - RSet set = redisson.getSet("list", StringCodec.INSTANCE); - set.add("1"); - set.add("3"); - set.add("12"); - - assertThat(set.readSort(null, null, SortOrder.ASC, -1, -1, true)) - .containsExactly("1", "12", "3"); - } - @Test public void testSortOrderAlpha(){ RSet set = redisson.getSet("list", StringCodec.INSTANCE); @@ -168,7 +157,9 @@ public class RedissonSetTest extends BaseTest { set.add("3"); set.add("12"); - assertThat(set.readSort(null, null, SortOrder.DESC, -1, -1, true)) + assertThat(set.readSortAlpha(SortOrder.ASC)) + .containsExactly("1", "12", "3"); + assertThat(set.readSortAlpha(SortOrder.DESC)) .containsExactly("3", "12", "1"); } @@ -179,9 +170,9 @@ public class RedissonSetTest extends BaseTest { set.add("3"); set.add("12"); - assertThat(set.readSort(null, null, SortOrder.DESC, 0, 2, true)) + assertThat(set.readSortAlpha(SortOrder.DESC, 0, 2)) .containsExactly("3", "12"); - assertThat(set.readSort(null, null, SortOrder.DESC, 1, 2, true)) + assertThat(set.readSortAlpha(SortOrder.DESC, 1, 2)) .containsExactly("12", "1"); } @@ -197,11 +188,11 @@ public class RedissonSetTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = set - .readSort("test*", null, SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", SortOrder.DESC); assertThat(descSort).containsExactly(2, 1, 3); Collection ascSort = set - .readSort("test*", null, SortOrder.ASC, -1, -1, true); + .readSortAlpha("test*", SortOrder.ASC); assertThat(ascSort).containsExactly(3, 1, 2); } @@ -217,11 +208,11 @@ public class RedissonSetTest extends BaseTest { redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); Collection descSort = set - .readSort("test*", null, SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", SortOrder.DESC,1, 2); assertThat(descSort).containsExactly(1, 3); Collection ascSort = set - .readSort("test*", null, SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", SortOrder.ASC,1, 2); assertThat(ascSort).containsExactly(1, 2); } @@ -241,11 +232,11 @@ public class RedissonSetTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC); assertThat(descSort).containsExactly("obj2", "obj1", "obj3"); Collection ascSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC); assertThat(ascSort).containsExactly("obj3", "obj1", "obj2"); } @@ -265,11 +256,11 @@ public class RedissonSetTest extends BaseTest { redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3"); Collection descSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2); assertThat(descSort).containsExactly("obj1", "obj3"); Collection ascSort = set - .readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true); + .readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2); assertThat(ascSort).containsExactly("obj1", "obj2"); }