diff --git a/redisson/src/main/java/org/redisson/RedissonList.java b/redisson/src/main/java/org/redisson/RedissonList.java index 6c2fa6d41..73608583b 100644 --- a/redisson/src/main/java/org/redisson/RedissonList.java +++ b/redisson/src/main/java/org/redisson/RedissonList.java @@ -636,7 +636,7 @@ public class RedissonList extends RedissonExpirable implements RList { @Override public RFuture> readSortAsync(SortOrder order) { - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), order); + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), order); } @Override @@ -646,7 +646,7 @@ public class RedissonList extends RedissonExpirable implements RList { @Override public RFuture> readSortAsync(SortOrder order, int offset, int count) { - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "LIMIT", offset, count, order); + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "LIMIT", offset, count, order); } @Override @@ -656,7 +656,7 @@ public class RedissonList extends RedissonExpirable implements RList { @Override public RFuture> readSortAsync(String byPattern, SortOrder order) { - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "BY", byPattern, order); + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, order); } @Override @@ -666,7 +666,7 @@ public class RedissonList extends RedissonExpirable implements RList { @Override public RFuture> readSortAsync(String byPattern, SortOrder order, int offset, int count) { - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "BY", byPattern, "LIMIT", offset, count, order); + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, "LIMIT", offset, count, order); } @Override @@ -707,7 +707,7 @@ public class RedissonList extends RedissonExpirable implements RList { } params.add(order); - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, params.toArray()); + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, params.toArray()); } @Override @@ -790,7 +790,7 @@ public class RedissonList extends RedissonExpirable implements RList { params.add("STORE"); params.add(destName); - return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); + return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); } } diff --git a/redisson/src/main/java/org/redisson/RedissonSet.java b/redisson/src/main/java/org/redisson/RedissonSet.java index d84db3b7f..3d88107e9 100644 --- a/redisson/src/main/java/org/redisson/RedissonSet.java +++ b/redisson/src/main/java/org/redisson/RedissonSet.java @@ -19,12 +19,14 @@ import java.net.InetSocketAddress; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Set; import org.redisson.api.RFuture; import org.redisson.api.RSet; +import org.redisson.api.SortOrder; import org.redisson.client.codec.Codec; import org.redisson.client.protocol.RedisCommand; import org.redisson.client.protocol.RedisCommand.ValueType; @@ -356,4 +358,168 @@ public class RedissonSet extends RedissonExpirable implements RSet { } } + @Override + public Set readSort(SortOrder order) { + return get(readSortAsync(order)); + } + + @Override + public RFuture> readSortAsync(SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), order); + } + + @Override + public Set readSort(SortOrder order, int offset, int count) { + return get(readSortAsync(order, offset, count)); + } + + @Override + public RFuture> readSortAsync(SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, order); + } + + @Override + public Set readSort(String byPattern, SortOrder order) { + return get(readSortAsync(byPattern, order)); + } + + @Override + public RFuture> readSortAsync(String byPattern, SortOrder order) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, order); + } + + @Override + public Set readSort(String byPattern, SortOrder order, int offset, int count) { + return get(readSortAsync(byPattern, order, offset, count)); + } + + @Override + public RFuture> readSortAsync(String byPattern, SortOrder order, int offset, int count) { + return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "LIMIT", offset, count, order); + } + + @Override + public Collection readSort(String byPattern, List getPatterns, SortOrder order) { + return (Collection)get(readSortAsync(byPattern, getPatterns, order)); + } + + @Override + 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 RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, int offset, int count) { + 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); + } + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } + 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)); + } + + @Override + public RFuture sortToAsync(String destName, SortOrder order) { + return sortToAsync(destName, null, Collections.emptyList(), order, -1, -1); + } + + @Override + public int sortTo(String destName, SortOrder order, int offset, int count) { + return get(sortToAsync(destName, order, offset, count)); + } + + @Override + public RFuture sortToAsync(String destName, SortOrder order, int offset, int count) { + return sortToAsync(destName, null, Collections.emptyList(), order, offset, count); + } + + @Override + public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) { + return get(sortToAsync(destName, byPattern, order, offset, count)); + } + + @Override + public int sortTo(String destName, String byPattern, SortOrder order) { + return get(sortToAsync(destName, byPattern, order)); + } + + @Override + public RFuture sortToAsync(String destName, String byPattern, SortOrder order) { + return sortToAsync(destName, byPattern, Collections.emptyList(), order, -1, -1); + } + + @Override + public RFuture sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) { + return sortToAsync(destName, byPattern, Collections.emptyList(), order, offset, count); + } + + @Override + public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order) { + return get(sortToAsync(destName, byPattern, getPatterns, order)); + } + + @Override + public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order) { + return sortToAsync(destName, byPattern, getPatterns, order, -1, -1); + } + + @Override + public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) { + return get(sortToAsync(destName, byPattern, getPatterns, order, offset, count)); + } + + @Override + public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, int offset, int count) { + 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); + } + for (String pattern : getPatterns) { + params.add("GET"); + params.add(pattern); + } + params.add(order); + params.add("STORE"); + params.add(destName); + + return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray()); + } + } diff --git a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java index 234dd41a3..049f0d292 100644 --- a/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java +++ b/redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java @@ -27,6 +27,7 @@ import java.util.concurrent.TimeUnit; import org.redisson.api.RFuture; import org.redisson.api.RSet; +import org.redisson.api.SortOrder; import org.redisson.client.codec.Codec; import org.redisson.client.protocol.RedisCommand; import org.redisson.client.protocol.RedisCommand.ValueType; @@ -55,6 +56,7 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R private static final RedisCommand EVAL_CONTAINS_VALUE = new RedisCommand("EVAL", new BooleanReplayConvertor(), 6, Arrays.asList(ValueType.MAP_KEY, ValueType.MAP_VALUE)); private static final RedisCommand EVAL_CONTAINS_ALL_WITH_VALUES = new RedisCommand("EVAL", new BooleanReplayConvertor(), 7, ValueType.OBJECTS); + private final RSet set; private final Object key; private final String timeoutSetName; @@ -62,6 +64,7 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R super(codec, commandExecutor, name); this.timeoutSetName = timeoutSetName; this.key = key; + this.set = new RedissonSet(codec, commandExecutor, name); } @Override @@ -225,17 +228,17 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R @Override public boolean add(V e) { - return get(addAsync(e)); + return set.add(e); } @Override public RFuture addAsync(V e) { - return commandExecutor.writeAsync(getName(), codec, RedisCommands.SADD_SINGLE, getName(), e); + return set.addAsync(e); } @Override public V removeRandom() { - return get(removeRandomAsync()); + return set.removeRandom(); } @Override @@ -515,4 +518,106 @@ public class RedissonSetMultimapValues extends RedissonExpirable implements R return commandExecutor.writeAsync(getName(), codec, RedisCommands.SINTER, args.toArray()); } + public RFuture> readSortAsync(SortOrder order) { + return set.readSortAsync(order); + } + + public Set readSort(SortOrder order) { + return set.readSort(order); + } + + public RFuture> readSortAsync(SortOrder order, int offset, int count) { + return set.readSortAsync(order, offset, count); + } + + public Set readSort(SortOrder order, int offset, int count) { + return set.readSort(order, offset, count); + } + + public Set readSort(String byPattern, SortOrder order) { + return set.readSort(byPattern, order); + } + + public RFuture> readSortAsync(String byPattern, SortOrder order) { + return set.readSortAsync(byPattern, order); + } + + public Set readSort(String byPattern, SortOrder order, int offset, int count) { + return set.readSort(byPattern, order, offset, count); + } + + public RFuture> readSortAsync(String byPattern, SortOrder order, int offset, int count) { + return set.readSortAsync(byPattern, order, offset, count); + } + + public Collection readSort(String byPattern, List getPatterns, SortOrder order) { + return set.readSort(byPattern, getPatterns, order); + } + + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order) { + return set.readSortAsync(byPattern, getPatterns, order); + } + + public Collection readSort(String byPattern, List getPatterns, SortOrder order, int offset, + int count) { + return set.readSort(byPattern, getPatterns, order, offset, count); + } + + public RFuture> readSortAsync(String byPattern, List getPatterns, SortOrder order, + int offset, int count) { + return set.readSortAsync(byPattern, getPatterns, order, offset, count); + } + + public int sortTo(String destName, SortOrder order) { + return set.sortTo(destName, order); + } + + public RFuture sortToAsync(String destName, SortOrder order) { + return set.sortToAsync(destName, order); + } + + public int sortTo(String destName, SortOrder order, int offset, int count) { + return set.sortTo(destName, order, offset, count); + } + + public RFuture sortToAsync(String destName, SortOrder order, int offset, int count) { + return set.sortToAsync(destName, order, offset, count); + } + + public int sortTo(String destName, String byPattern, SortOrder order) { + return set.sortTo(destName, byPattern, order); + } + + public RFuture sortToAsync(String destName, String byPattern, SortOrder order) { + return set.sortToAsync(destName, byPattern, order); + } + + public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) { + return set.sortTo(destName, byPattern, order, offset, count); + } + + public RFuture sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) { + return set.sortToAsync(destName, byPattern, order, offset, count); + } + + public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order) { + return set.sortTo(destName, byPattern, getPatterns, order); + } + + public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order) { + return set.sortToAsync(destName, byPattern, getPatterns, order); + } + + public int sortTo(String destName, String byPattern, List getPatterns, SortOrder order, int offset, + int count) { + return set.sortTo(destName, byPattern, getPatterns, order, offset, count); + } + + public RFuture sortToAsync(String destName, String byPattern, List getPatterns, SortOrder order, + int offset, int count) { + return set.sortToAsync(destName, byPattern, getPatterns, order, offset, count); + } + + + } diff --git a/redisson/src/main/java/org/redisson/api/RSet.java b/redisson/src/main/java/org/redisson/api/RSet.java index 3c5d3ab71..2d0e92dc1 100644 --- a/redisson/src/main/java/org/redisson/api/RSet.java +++ b/redisson/src/main/java/org/redisson/api/RSet.java @@ -24,7 +24,7 @@ import java.util.Set; * * @param value */ -public interface RSet extends Set, RExpirable, RSetAsync { +public interface RSet extends Set, RExpirable, RSetAsync, RSortable> { /** * Removes and returns random elements from set diff --git a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java index 8dd68909f..2c02dc0a6 100644 --- a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java +++ b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java @@ -184,7 +184,8 @@ public interface RedisCommands { RedisStrictCommand PFCOUNT = new RedisStrictCommand("PFCOUNT"); RedisStrictCommand PFMERGE = new RedisStrictCommand("PFMERGE", new VoidReplayConvertor()); - RedisCommand> SORT = new RedisCommand>("SORT", new ObjectListReplayDecoder()); + RedisCommand> SORT_LIST = new RedisCommand>("SORT", new ObjectListReplayDecoder()); + RedisCommand> SORT_SET = new RedisCommand>("SORT", new ObjectSetReplayDecoder()); RedisCommand SORT_TO = new RedisCommand("SORT", new IntegerReplayConvertor()); RedisStrictCommand RPOP = new RedisStrictCommand("RPOP"); diff --git a/redisson/src/test/java/org/redisson/RedissonSetTest.java b/redisson/src/test/java/org/redisson/RedissonSetTest.java index 0d7794368..e0779d3ac 100644 --- a/redisson/src/test/java/org/redisson/RedissonSetTest.java +++ b/redisson/src/test/java/org/redisson/RedissonSetTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat; import java.io.Serializable; import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; @@ -13,7 +14,11 @@ import java.util.concurrent.ExecutionException; import org.junit.Assert; import org.junit.Test; import org.redisson.api.RFuture; +import org.redisson.api.RList; import org.redisson.api.RSet; +import org.redisson.api.SortOrder; +import org.redisson.client.codec.IntegerCodec; +import org.redisson.client.codec.StringCodec; public class RedissonSetTest extends BaseTest { @@ -31,6 +36,168 @@ public class RedissonSetTest extends BaseTest { } + @Test + public void testSortOrder() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + Set descSort = list.readSort(SortOrder.DESC); + assertThat(descSort).containsExactly(3, 2, 1); + + Set ascSort = list.readSort(SortOrder.ASC); + assertThat(ascSort).containsExactly(1, 2, 3); + } + + @Test + public void testSortOrderLimit() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + Set descSort = list.readSort(SortOrder.DESC, 1, 2); + assertThat(descSort).containsExactly(2, 1); + + Set ascSort = list.readSort(SortOrder.ASC, 1, 2); + assertThat(ascSort).containsExactly(2, 3); + } + + @Test + public void testSortOrderByPattern() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Set descSort = list.readSort("test*", SortOrder.DESC); + assertThat(descSort).containsExactly(1, 2, 3); + + Set ascSort = list.readSort("test*", SortOrder.ASC); + assertThat(ascSort).containsExactly(3, 2, 1); + } + + @Test + public void testSortOrderByPatternLimit() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + Set descSort = list.readSort("test*", SortOrder.DESC, 1, 2); + assertThat(descSort).containsExactly(2, 3); + + Set ascSort = list.readSort("test*", SortOrder.ASC, 1, 2); + assertThat(ascSort).containsExactly(2, 1); + } + + @Test + public void testSortOrderByPatternGet() { + RSet list = redisson.getSet("list", StringCodec.INSTANCE); + list.add("1"); + list.add("2"); + list.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(1); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(3); + + 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); + assertThat(descSort).containsExactly("obj3", "obj2", "obj1"); + + Collection ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC); + assertThat(ascSort).containsExactly("obj1", "obj2", "obj3"); + } + + @Test + public void testSortOrderByPatternGetLimit() { + RSet list = redisson.getSet("list", StringCodec.INSTANCE); + list.add("1"); + list.add("2"); + list.add("3"); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(1); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(3); + + 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); + assertThat(descSort).containsExactly("obj2", "obj1"); + + Collection ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2); + assertThat(ascSort).containsExactly("obj2", "obj3"); + } + + @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"); + + assertThat(list.sortTo("test4", SortOrder.ASC)).isEqualTo(3); + RList list3 = redisson.getList("test4", StringCodec.INSTANCE); + assertThat(list3).containsExactly("1", "2", "3"); + + } + + @Test + public void testSortToLimit() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + assertThat(list.sortTo("test3", SortOrder.DESC, 1, 2)).isEqualTo(2); + RList list2 = redisson.getList("test3", StringCodec.INSTANCE); + assertThat(list2).containsExactly("2", "1"); + + assertThat(list.sortTo("test4", SortOrder.ASC, 1, 2)).isEqualTo(2); + RList list3 = redisson.getList("test4", StringCodec.INSTANCE); + assertThat(list3).containsExactly("2", "3"); + } + + @Test + public void testSortToByPattern() { + RSet list = redisson.getSet("list", IntegerCodec.INSTANCE); + list.add(1); + list.add(2); + list.add(3); + + redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3); + redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2); + redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1); + + assertThat(list.sortTo("tester3", "test*", SortOrder.DESC, 1, 2)).isEqualTo(2); + RList list2 = redisson.getList("tester3", StringCodec.INSTANCE); + assertThat(list2).containsExactly("2", "3"); + + assertThat(list.sortTo("tester4", "test*", SortOrder.ASC, 1, 2)).isEqualTo(2); + RList list3 = redisson.getList("tester4", StringCodec.INSTANCE); + assertThat(list3).containsExactly("2", "1"); + } + + @Test public void testRemoveRandom() { RSet set = redisson.getSet("simple");