github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Support sort alpha for list,set,sorted set. #1607

Browse Source
pull/1613/head
Pepe Lu 7 years ago
parent d108318e5d
commit 423910bff4
12 changed files with 517 additions and 82 deletions
Show Stats Download Patch File Download Diff File

46
redisson/src/main/java/org/redisson/RedissonList.java
Unescape Escape View File

@ -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<V> extends RedissonExpirable implements RList<V> {
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return readSortAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha));
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
List<Object> params = new ArrayList<Object>();
params.add(getName());
if (byPattern != null) {
@ -751,15 +752,22 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
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));

11
redisson/src/main/java/org/redisson/RedissonListMultimapValues.java
Unescape Escape View File

@ -741,12 +741,23 @@ public class RedissonListMultimapValues<V> extends RedissonExpirable implements
return list.readSort(byPattern, getPatterns, order, offset, count);
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return list.readSort(byPattern, getPatterns, order, offset, count, alpha);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset,
int count) {
return list.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> 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);

34
redisson/src/main/java/org/redisson/RedissonScoredSortedSet.java
Unescape Escape View File

@ -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<V> extends RedissonExpirable implements RSc
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha));
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
List<Object> params = new ArrayList<Object>();
params.add(getName());
if (byPattern != null) {
@ -904,15 +911,22 @@ public class RedissonScoredSortedSet<V> 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));

35
redisson/src/main/java/org/redisson/RedissonSet.java
Unescape Escape View File

@ -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<V> extends RedissonExpirable implements RSet<V>, ScanIt
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count, alpha));
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
List<Object> params = new ArrayList<Object>();
params.add(getName());
if (byPattern != null) {
@ -461,15 +467,22 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, 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));

15
redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java
Unescape Escape View File

@ -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<V> extends RedissonExpirable implements R
return set.readSort(byPattern, getPatterns, order, offset, count);
}
@Override
public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return set.readSort(byPattern, getPatterns, order, offset, count, alpha);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order,
int offset, int count) {
return set.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> 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);

17
redisson/src/main/java/org/redisson/api/RSortable.java
Unescape Escape View File

@ -87,7 +87,21 @@ public interface RSortable<V> extends RSortableAsync<V> {
* @return sorted collection
*/
<T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
/**
* Read data in sorted view
*
* @param <T> 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
*/
<T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha);
/**
* Sort data and store to <code>destName</code> list
*
@ -153,5 +167,4 @@ public interface RSortable<V> extends RSortableAsync<V> {
* @return length of sorted data
*/
int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
}

16
redisson/src/main/java/org/redisson/api/RSortableAsync.java
Unescape Escape View File

@ -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<V> {
*/
<T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
/**
* Read data in sorted view
*
* @param <T> 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
*/
<T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha);
/**
* Sort data and store to <code>destName</code> list
*
@ -153,5 +168,4 @@ public interface RSortableAsync<V> {
* @return length of sorted data
*/
RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
}

13
redisson/src/main/java/org/redisson/transaction/BaseTransactionalSet.java
Unescape Escape View File

@ -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<V> extends BaseTransactionalObject {
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
throw new UnsupportedOperationException();
}
public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}

12
redisson/src/main/java/org/redisson/transaction/RedissonTransactionalSet.java
Unescape Escape View File

@ -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<V> extends RedissonSet<V> {
checkState();
return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count, boolean alpha) {
return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count, alpha);
}
@Override
public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
checkState();

135
redisson/src/test/java/org/redisson/RedissonListTest.java
Unescape Escape View File

@ -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<String> ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2);
assertThat(ascSort).containsExactly("obj2", "obj3");
}
@Test
public void testSortAlpha(){
RList<String> 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<String> 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<String> 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<Integer> 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<Integer> descSort = list
.readSort("test*", null, SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = list
.readSort("test*", null, SortOrder.ASC, -1, -1, true);
assertThat(ascSort).containsExactly(3, 1, 2);
}
@Test
public void testSortOrderByPatternAlphaLimit(){
RList<Integer> 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<Integer> descSort = list
.readSort("test*", null, SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = list
.readSort("test*", null, SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly(1, 2);
}
@Test
public void testSortOrderByPatternGetAlpha() {
RList<String> 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<String> descSort = list
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = list
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true);
assertThat(ascSort).containsExactly("obj3", "obj1", "obj2");
}
@Test
public void testSortOrderByPatternGetAlphaLimit() {
RList<String> 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<String> descSort = list
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = list
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly("obj1", "obj2");
}
@Test
public void testSortTo() {
RList<String> list = redisson.getList("list", IntegerCodec.INSTANCE);

132
redisson/src/test/java/org/redisson/RedissonScoredSortedSetTest.java
Unescape Escape View File

@ -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<String> ascSort = set.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2);
assertThat(ascSort).containsExactly("obj2", "obj3");
}
@Test
public void testSortAlpha(){
RScoredSortedSet<Integer> 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<Integer> 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<Integer> 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<Integer> 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<Integer> descSort = set
.readSort("test*", null, SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = set
.readSort("test*", null, SortOrder.ASC, -1, -1, true);
assertThat(ascSort).containsExactly(3, 1, 2);
}
@Test
public void testSortOrderByPatternAlphaLimit(){
RScoredSortedSet<Integer> 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<Integer> descSort = set
.readSort("test*", null, SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = set
.readSort("test*", null, SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly(1, 2);
}
@Test
public void testSortOrderByPatternGetAlpha() {
RScoredSortedSet<Integer> 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<String> descSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true);
assertThat(ascSort).containsExactly("obj3", "obj1", "obj2");
}
@Test
public void testSortOrderByPatternGetAlphaLimit() {
RScoredSortedSet<Integer> 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<String> descSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly("obj1", "obj2");
}
@Test
public void testSortTo() {
RScoredSortedSet<Integer> set = redisson.getScoredSortedSet("list", IntegerCodec.INSTANCE);

133
redisson/src/test/java/org/redisson/RedissonSetTest.java
Unescape Escape View File

@ -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<String> ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2);
assertThat(ascSort).containsExactly("obj2", "obj3");
}
@Test
public void testSortAlpha(){
RSet<String> 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<String> 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<String> 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<Integer> 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<Integer> descSort = set
.readSort("test*", null, SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = set
.readSort("test*", null, SortOrder.ASC, -1, -1, true);
assertThat(ascSort).containsExactly(3, 1, 2);
}
@Test
public void testSortOrderByPatternAlphaLimit(){
RSet<Integer> 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<Integer> descSort = set
.readSort("test*", null, SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = set
.readSort("test*", null, SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly(1, 2);
}
@Test
public void testSortOrderByPatternGetAlpha() {
RSet<String> 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<String> descSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,-1, -1, true);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,-1, -1, true);
assertThat(ascSort).containsExactly("obj3", "obj1", "obj2");
}
@Test
public void testSortOrderByPatternGetAlphaLimit() {
RSet<String> 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<String> descSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2, true);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = set
.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2, true);
assertThat(ascSort).containsExactly("obj1", "obj2");
}
@Test
public void testSortTo() {
RSet<String> list = redisson.getSet("list", IntegerCodec.INSTANCE);
list.add("1");
list.add("2");
list.add("3");
assertThat(list.sortTo("test3", SortOrder.DESC)).isEqualTo(3);
RList<String> list2 = redisson.getList("test3", StringCodec.INSTANCE);
assertThat(list2).containsExactly("3", "2", "1");

Write Preview
Loading…
Cancel
Save