Merge pull request from Pepe-Lu/master

Support sort alpha for list,set,sorted set. 
pull/1639/head
Nikita Koksharov committed by GitHub
commit 26074a4ba8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -728,7 +728,7 @@ 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));
@ -736,30 +736,69 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
List<Object> params = new ArrayList<Object>();
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_LIST, params.toArray());
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public List<V> readSortAlpha(SortOrder order) {
return get(readSortAlphaAsync(order));
}
@Override
public RFuture<List<V>> readSortAlphaAsync(SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "ALPHA", order);
}
@Override
public List<V> readSortAlpha(SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(order, offset, count));
}
@Override
public RFuture<List<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "LIMIT", offset, count, "ALPHA", order);
}
@Override
public List<V> readSortAlpha(String byPattern, SortOrder order) {
return get(readSortAlphaAsync(byPattern, order));
}
@Override
public RFuture<List<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, "ALPHA", order);
}
@Override
public List<V> readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(byPattern, order, offset, count));
}
@Override
public RFuture<List<V>> 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 <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order));
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, true);
}
@Override
public int sortTo(String destName, SortOrder order) {
return get(sortToAsync(destName, order));
@ -843,4 +882,36 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
}
private <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) {
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());
}
}

@ -747,6 +747,66 @@ public class RedissonListMultimapValues<V> extends RedissonExpirable implements
return list.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public List<V> readSortAlpha(SortOrder order) {
return list.readSortAlpha(order);
}
@Override
public List<V> readSortAlpha(SortOrder order, int offset, int count) {
return list.readSortAlpha(order, offset, count);
}
@Override
public List<V> readSortAlpha(String byPattern, SortOrder order) {
return list.readSortAlpha(byPattern, order);
}
@Override
public List<V> readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return list.readSortAlpha(byPattern, order, offset, count);
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order) {
return list.readSortAlpha(byPattern, getPatterns, order);
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return list.readSortAlpha(byPattern, getPatterns, order, offset, count);
}
@Override
public RFuture<List<V>> readSortAlphaAsync(SortOrder order) {
return list.readSortAlphaAsync(order);
}
@Override
public RFuture<List<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return list.readSortAlphaAsync(order, offset, count);
}
@Override
public RFuture<List<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return list.readSortAlphaAsync(byPattern, order);
}
@Override
public RFuture<List<V>> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) {
return list.readSortAlphaAsync(byPattern, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return list.readSortAlphaAsync(byPattern, getPatterns, order);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return list.readSortAlphaAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public int sortTo(String destName, SortOrder order) {
return list.sortTo(destName, order);

@ -889,30 +889,69 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
List<Object> params = new ArrayList<Object>();
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());
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public Set<V> readSortAlpha(SortOrder order) {
return get(readSortAlphaAsync(order));
}
@Override
public Set<V> readSortAlpha(SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(order, offset, count));
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order) {
return get(readSortAlphaAsync(byPattern, order));
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(byPattern, order, offset, count));
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order));
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "ALPHA", order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, "ALPHA", order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "ALPHA", order);
}
@Override
public RFuture<Set<V>> 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 <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, true);
}
@Override
public int sortTo(String destName, SortOrder order) {
return get(sortToAsync(destName, order));
@ -995,5 +1034,36 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
}
private <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) {
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());
}
}

@ -446,30 +446,69 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, ScanIt
@Override
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
List<Object> params = new ArrayList<Object>();
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());
return readSortAsync(byPattern, getPatterns, order, offset, count, false);
}
@Override
public Set<V> readSortAlpha(SortOrder order) {
return get(readSortAlphaAsync(order));
}
@Override
public Set<V> readSortAlpha(SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(order, offset, count));
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order) {
return get(readSortAlphaAsync(byPattern, order));
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return get(readSortAlphaAsync(byPattern, order, offset, count));
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order));
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return (Collection<T>)get(readSortAlphaAsync(byPattern, getPatterns, order, offset, count));
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "ALPHA", order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, "ALPHA", order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "ALPHA", order);
}
@Override
public RFuture<Set<V>> 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 <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return readSortAlphaAsync(byPattern, getPatterns, order, -1, -1);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return readSortAsync(byPattern, getPatterns, order, offset, count, true);
}
@Override
public int sortTo(String destName, SortOrder order) {
return get(sortToAsync(destName, order));
@ -577,5 +616,36 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V>, ScanIt
return commandExecutor.readAsync(client, name, codec, RedisCommands.SSCAN, name, startPos, "MATCH", pattern, "COUNT", count);
}
private <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) {
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());
}
}

@ -608,6 +608,66 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
return set.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public Set<V> readSortAlpha(SortOrder order) {
return set.readSortAlpha(order);
}
@Override
public Set<V> readSortAlpha(SortOrder order, int offset, int count) {
return set.readSortAlpha(order, offset, count);
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order) {
return set.readSortAlpha(byPattern, order);
}
@Override
public Set<V> readSortAlpha(String byPattern, SortOrder order, int offset, int count) {
return set.readSortAlpha(byPattern, order, offset, count);
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order) {
return set.readSortAlpha(byPattern, getPatterns, order);
}
@Override
public <T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return set.readSortAlpha(byPattern, getPatterns, order, offset, count);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order) {
return set.readSortAlphaAsync(order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return set.readSortAlphaAsync(order, offset, count);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return set.readSortAlphaAsync(byPattern, order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) {
return set.readSortAlphaAsync(byPattern, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return set.readSortAlphaAsync(byPattern, getPatterns, order);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return set.readSortAlphaAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public int sortTo(String destName, SortOrder order) {
return set.sortTo(destName, order);

@ -87,7 +87,69 @@ 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 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 <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
* @return sorted collection lexicographically
*/
<T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order);
/**
* Read data in sorted view lexicographically
*
* @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
* @return sorted collection lexicographically
*/
<T> Collection<T> readSortAlpha(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
/**
* Sort data and store to <code>destName</code> list
*

@ -88,6 +88,68 @@ 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 lexicographically
*
* @param order for sorted data
* @return sorted collection lexicographically
*/
RFuture<V> 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<V> 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<V> 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<V> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count);
/**
* Read data in sorted view lexicographically
*
* @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
* @return sorted collection lexicographically
*/
<T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order);
/**
* Read data in sorted view lexicographically
*
* @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
* @return sorted collection lexicographically
*/
<T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count);
/**
* Sort data and store to <code>destName</code> list
*
@ -153,5 +215,5 @@ 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);
}

@ -494,11 +494,35 @@ public abstract class BaseTransactionalSet<V> extends BaseTransactionalObject {
public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order) {
throw new UnsupportedOperationException();
}
public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order) {
throw new UnsupportedOperationException();
}
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
throw new UnsupportedOperationException();
}
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
throw new UnsupportedOperationException();
}
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}
public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
throw new UnsupportedOperationException();
}

@ -202,7 +202,37 @@ public class RedissonTransactionalSet<V> extends RedissonSet<V> {
checkState();
return transactionalSet.readSortAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order) {
return transactionalSet.readSortAlphaAsync(order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(SortOrder order, int offset, int count) {
return transactionalSet.readSortAlphaAsync(order, offset, count);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order) {
return transactionalSet.readSortAlphaAsync(byPattern, order);
}
@Override
public RFuture<Set<V>> readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count) {
return transactionalSet.readSortAlphaAsync(byPattern, order, offset, count);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order) {
return transactionalSet.readSortAlphaAsync(byPattern, getPatterns, order);
}
@Override
public <T> RFuture<Collection<T>> readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
return transactionalSet.readSortAlphaAsync(byPattern, getPatterns, order, offset, count);
}
@Override
public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
checkState();

@ -141,7 +141,121 @@ 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 testSortOrderAlpha(){
RList<String> list = redisson.getList("list", StringCodec.INSTANCE);
list.add("1");
list.add("3");
list.add("12");
assertThat(list.readSortAlpha( SortOrder.ASC))
.containsExactly("1", "12", "3");
assertThat(list.readSortAlpha( SortOrder.DESC))
.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.readSortAlpha(SortOrder.DESC, 0, 2))
.containsExactly("3", "12");
assertThat(list.readSortAlpha(SortOrder.DESC, 1, 2))
.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
.readSortAlpha("test*", SortOrder.DESC);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = list
.readSortAlpha("test*", SortOrder.ASC);
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
.readSortAlpha("test*", SortOrder.DESC,1, 2);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = list
.readSortAlpha("test*", SortOrder.ASC,1, 2);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = list
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = list
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2);
assertThat(ascSort).containsExactly("obj1", "obj2");
}
@Test
public void testSortTo() {
RList<String> list = redisson.getList("list", IntegerCodec.INSTANCE);

@ -173,7 +173,121 @@ 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 testSortOrderAlpha(){
RScoredSortedSet<String> set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE);
set.add(10,"1");
set.add(9,"3");
set.add(8,"12");
assertThat(set.readSortAlpha(SortOrder.ASC))
.containsExactly("1", "12", "3");
assertThat(set.readSortAlpha(SortOrder.DESC))
.containsExactly("3", "12", "1");
}
@Test
public void testSortOrderLimitAlpha(){
RScoredSortedSet<String> set = redisson.getScoredSortedSet("list", StringCodec.INSTANCE);
set.add(10,"1");
set.add(9,"3");
set.add(8,"12");
assertThat(set.readSortAlpha(SortOrder.DESC, 0, 2))
.containsExactly("3", "12");
assertThat(set.readSortAlpha(SortOrder.DESC, 1, 2))
.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
.readSortAlpha("test*", SortOrder.DESC);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = set
.readSortAlpha("test*", SortOrder.ASC);
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
.readSortAlpha("test*", SortOrder.DESC,1,2);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = set
.readSortAlpha("test*", SortOrder.ASC,1,2);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = set
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1,2);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = set
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2);
assertThat(ascSort).containsExactly("obj1", "obj2");
}
@Test
public void testSortTo() {
RScoredSortedSet<Integer> set = redisson.getScoredSortedSet("list", IntegerCodec.INSTANCE);

@ -149,14 +149,128 @@ 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 testSortOrderAlpha(){
RSet<String> set = redisson.getSet("list", StringCodec.INSTANCE);
set.add("1");
set.add("3");
set.add("12");
assertThat(set.readSortAlpha(SortOrder.ASC))
.containsExactly("1", "12", "3");
assertThat(set.readSortAlpha(SortOrder.DESC))
.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.readSortAlpha(SortOrder.DESC, 0, 2))
.containsExactly("3", "12");
assertThat(set.readSortAlpha(SortOrder.DESC, 1, 2))
.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
.readSortAlpha("test*", SortOrder.DESC);
assertThat(descSort).containsExactly(2, 1, 3);
Collection<Integer> ascSort = set
.readSortAlpha("test*", SortOrder.ASC);
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
.readSortAlpha("test*", SortOrder.DESC,1, 2);
assertThat(descSort).containsExactly(1, 3);
Collection<Integer> ascSort = set
.readSortAlpha("test*", SortOrder.ASC,1, 2);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC);
assertThat(descSort).containsExactly("obj2", "obj1", "obj3");
Collection<String> ascSort = set
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC);
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
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.DESC,1, 2);
assertThat(descSort).containsExactly("obj1", "obj3");
Collection<String> ascSort = set
.readSortAlpha("test*", Arrays.asList("tester*"), SortOrder.ASC,1, 2);
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");

Loading…
Cancel
Save