Package io.toro.martini.redis

Class RedisSortedSetMethods

java.lang.Object

io.toro.martini.redis.RedisBaseMethods

io.toro.martini.redis.RedisSortedSetMethods

public class RedisSortedSetMethods
extends io.toro.martini.redis.RedisBaseMethods

Methods for Sorted Sets.

Constructor Summary

Constructors

Constructor	Description
RedisSortedSetMethods(io.toro.martini.database.DataSourceManager dataSourceManager)

Method Summary

Modifier and Type	Method	Description
static GloopModel	bzpopmax(String connectionName, long timeout, GloopExecutionContext context, Object... keys)	Removes and returns a member with the highest scores in the sorted set stored at one of the keys.
static Future<KeyValue<Object,ScoredValue<Object>>>	bzpopmaxAsync(String connectionName, long timeout, GloopExecutionContext context, Object... keys)	Asynchronously removes and returns a member with the highest scores in the sorted set stored at one of the keys.
static GloopModel	bzpopmin(String connectionName, long timeout, GloopExecutionContext context, Object... keys)	Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
static Future<KeyValue<Object,ScoredValue<Object>>>	bzpopminAsync(String connectionName, long timeout, GloopExecutionContext context, Object... keys)	Asynchronously removes and returns a member with the lowest scores in the sorted set stored at one of the keys.
static Long	zadd(String connectionName, Object key, double score, Object member, GloopExecutionContext context)	Add one or more members to a sorted set, or update its score if it already exists.
static Long	zadd(String connectionName, Object key, ZAddArgs zaddArgs, double score, Object member, GloopExecutionContext context)	Add one or more members to a sorted set, or update its score if it already exists.
static Long	zadd(String connectionName, Object key, ZAddArgs zaddArgs, GloopExecutionContext context, ScoredValue<Object>... scoredValues)	Add one or more members to a sorted set, or update its score if it already exists.
static Long	zadd(String connectionName, Object key, ZAddArgs zaddArgs, GloopExecutionContext context, Object... scoresAndValues)	Add one or more members to a sorted set, or update its score if it already exists.
static Long	zadd(String connectionName, Object key, GloopExecutionContext context, ScoredValue<Object>... scoredValues)	Add one or more members to a sorted set, or update its score if it already exists.
static Long	zadd(String connectionName, Object key, GloopExecutionContext context, Object... scoresAndValues)	Add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, double score, Object member, GloopExecutionContext context)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, ZAddArgs zaddArgs, double score, Object member, GloopExecutionContext context)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, ZAddArgs zaddArgs, GloopExecutionContext context, ScoredValue<Object>... scoredValues)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, ZAddArgs zaddArgs, GloopExecutionContext context, Object... scoresAndValues)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, GloopExecutionContext context, ScoredValue<Object>... scoredValues)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Future<Long>	zaddAsync(String connectionName, Object key, GloopExecutionContext context, Object... scoresAndValues)	Asynchronously add one or more members to a sorted set, or update its score if it already exists.
static Double	zaddincr(String connectionName, Object key, double score, Object member, GloopExecutionContext context)	Add one or more members to a sorted set, or update its score if it already exists applying the INCR option.
static Double	zaddincr(String connectionName, Object key, ZAddArgs zaddArgs, double score, Object member, GloopExecutionContext context)	Add one or more members to a sorted set, or update its score if it already exists applying the INCR option.
static Future<Double>	zaddincrAsync(String connectionName, Object key, double score, Object member, GloopExecutionContext context)	Asynchronously add one or more members to a sorted set, or update its score if it already exists applying the iNCR option.
static Future<Double>	zaddincrAsync(String connectionName, Object key, ZAddArgs zaddArgs, double score, Object member, GloopExecutionContext context)	Asynchronously add one or more members to a sorted set, or update its score if it already exists applying the iNCR option.
static Long	zcard(String connectionName, Object key, GloopExecutionContext context)	Get the number of members in a sorted set.
static Future<Long>	zcardAsync(String connectionName, Object key, GloopExecutionContext context)	Asynchronously get the number of members in a sorted set.
static Long	zcount(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Count the members in a sorted set with scores within the given Range.
static Future<Long>	zcountAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously count the members in a sorted set with scores within the given Range.
static Double	zincrby(String connectionName, Object key, double amount, Object member, GloopExecutionContext context)	Increment the score of a member in a sorted set.
static Future<Double>	zincrbyAsync(String connectionName, Object key, double amount, Object member, GloopExecutionContext context)	Asynchronously increment the score of a member in a sorted set.
static Long	zinterstore(String connectionName, Object destination, ZStoreArgs storeArgs, GloopExecutionContext context, Object... keys)	Intersect multiple sorted sets and store the resulting sorted set in a new key.
static Long	zinterstore(String connectionName, Object destination, GloopExecutionContext context, Object... keys)	Intersect multiple sorted sets and store the resulting sorted set in a new key.
static Future<Long>	zinterstoreAsync(String connectionName, Object destination, ZStoreArgs storeArgs, GloopExecutionContext context, Object... keys)	Asynchronously intersect multiple sorted sets and store the resulting sorted set in a new key.
static Future<Long>	zinterstoreAsync(String connectionName, Object destination, GloopExecutionContext context, Object... keys)	Asynchronously intersect multiple sorted sets and store the resulting sorted set in a new key.
static Long	zlexcount(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Count the number of members in a sorted set between a given lexicographical range.
static Future<Long>	zlexcountAsync(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Asynchronously count the number of members in a sorted set between a given lexicographical range.
static List<ScoredValue<Object>>	zpopmax(String connectionName, Object key, long count, GloopExecutionContext context)	Removes and returns up to count members with the highest scores in the sorted set stored at key.
static ScoredValue<Object>	zpopmax(String connectionName, Object key, GloopExecutionContext context)	Removes and returns up to count members with the highest scores in the sorted set stored at key.
static Future<List<ScoredValue<Object>>>	zpopmaxAsync(String connectionName, Object key, long count, GloopExecutionContext context)	Asynchronously removes and returns up to count members with the highest scores in the sorted set stored at key.
static Future<ScoredValue<Object>>	zpopmaxAsync(String connectionName, Object key, GloopExecutionContext context)	Asynchronously removes and returns up to count members with the highest scores in the sorted set stored at key.
static List<ScoredValue<Object>>	zpopmin(String connectionName, Object key, long count, GloopExecutionContext context)	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
static ScoredValue<Object>	zpopmin(String connectionName, Object key, GloopExecutionContext context)	Removes and returns up to count members with the lowest scores in the sorted set stored at key.
static Future<List<ScoredValue<Object>>>	zpopminAsync(String connectionName, Object key, long count, GloopExecutionContext context)	Asynchronously removes and returns up to count members with the lowest scores in the sorted set stored at key.
static Future<ScoredValue<Object>>	zpopminAsync(String connectionName, Object key, GloopExecutionContext context)	Asynchronously removes and returns up to count members with the lowest scores in the sorted set stored at key.
static Long	zrange(String connectionName, ValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Return a range of members in a sorted set, by index.
static List<Object>	zrange(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Return a range of members in a sorted set, by index.
static Future<Long>	zrangeAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by index.
static Future<List<Object>>	zrangeAsync(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by index.
static List<Object>	zrangebylex(String connectionName, Object key, Range<Object> range, Limit limit, GloopExecutionContext context)	Return a range of members in a sorted set, by lexicographical range.
static List<Object>	zrangebylex(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Return a range of members in a sorted set, by lexicographical range.
static Future<List<Object>>	zrangebylexAsync(String connectionName, Object key, Range<Object> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by lexicographical range.
static Future<List<Object>>	zrangebylexAsync(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by lexicographical range.
static Long	zrangebyscore(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Stream over a range of members in a sorted set, by score.
static Long	zrangebyscore(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Stream over a range of members in a sorted set, by score.
static List<Object>	zrangebyscore(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Return a range of members in a sorted set, by score.
static List<Object>	zrangebyscore(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Return a range of members in a sorted set, by score.
static Future<Long>	zrangebyscoreAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously stream over a range of members in a sorted set, by score.
static Future<Long>	zrangebyscoreAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously stream over a range of members in a sorted set, by score.
static Future<List<Object>>	zrangebyscoreAsync(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by score.
static Future<List<Object>>	zrangebyscoreAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by score.
static Long	zrangebyscoreWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by score.
static Long	zrangebyscoreWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by score.
static List<ScoredValue<Object>>	zrangebyscoreWithScores(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Return a range of members with score in a sorted set, by score.
static List<ScoredValue<Object>>	zrangebyscoreWithScores(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Return a range of members with score in a sorted set, by score.
static Future<Long>	zrangebyscoreWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by score.
static Future<Long>	zrangebyscoreWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by score.
static Future<List<ScoredValue<Object>>>	zrangebyscoreWithScoresAsync(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members with score in a sorted set, by score.
static Future<List<ScoredValue<Object>>>	zrangebyscoreWithScoresAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously return a range of members with score in a sorted set, by score.
static Long	zrangeWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by index.
static List<ScoredValue<Object>>	zrangeWithScores(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Return a range of members with scores in a sorted set, by index.
static Future<Long>	zrangeWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by index.
static Future<List<ScoredValue<Object>>>	zrangeWithScoresAsync(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously return a range of members with scores in a sorted set, by index.
static Long	zrank(String connectionName, Object key, Object member, GloopExecutionContext context)	Determine the index of a member in a sorted set.
static Future<Long>	zrankAsync(String connectionName, Object key, Object member, GloopExecutionContext context)	Asynchronously determine the index of a member in a sorted set.
static Long	zrem(String connectionName, Object key, GloopExecutionContext context, Object... members)	Remove one or more members from a sorted set.
static Future<Long>	zremAsync(String connectionName, Object key, GloopExecutionContext context, Object... members)	Asynchronously remove one or more members from a sorted set.
static Long	zremrangebylex(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Remove all members in a sorted set between the given lexicographical range.
static Future<Long>	zremrangebylexAsync(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Asynchronously remove all members in a sorted set between the given lexicographical range.
static Long	zremrangebyrank(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Remove all members in a sorted set within the given indexes.
static Future<Long>	zremrangebyrankAsync(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously remove all members in a sorted set within the given indexes.
static Long	zremrangebyscore(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Remove all members in a sorted set within the given scores.
static Future<Long>	zremrangebyscoreAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously remove all members in a sorted set within the given scores.
static Long	zrevrange(String connectionName, ValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
static List<Object>	zrevrange(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Return a range of members in a sorted set, by index, with scores ordered from high to low.
static Future<Long>	zrevrangeAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously stream over a range of members in a sorted set, by index, with scores ordered from high to low.
static Future<List<Object>>	zrevrangeAsync(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by index, with scores ordered from high to low.
static List<Object>	zrevrangebylex(String connectionName, Object key, Range<Object> range, Limit limit, GloopExecutionContext context)	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
static List<Object>	zrevrangebylex(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Return a range of members in a sorted set, by lexicographical range ordered from high to low.
static Future<List<Object>>	zrevrangebylexAsync(String connectionName, Object key, Range<Object> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by lexicographical range ordered from high to low.
static Future<List<Object>>	zrevrangebylexAsync(String connectionName, Object key, Range<Object> range, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by lexicographical range ordered from high to low.
static Long	zrevrangebyscore(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
static Long	zrevrangebyscore(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
static List<Object>	zrevrangebyscore(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Return a range of members in a sorted set, by score, with scores ordered from high to low.
static List<Object>	zrevrangebyscore(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Return a range of members in a sorted set, by score, with scores ordered from high to low.
static Future<Long>	zrevrangebyscoreAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously stream over a range of members in a sorted set, by score, with scores ordered from high to low.
static Future<Long>	zrevrangebyscoreAsync(String connectionName, ValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously stream over a range of members in a sorted set, by score, with scores ordered from high to low.
static Future<List<Object>>	zrevrangebyscoreAsync(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by score, with scores ordered from high to low.
static Future<List<Object>>	zrevrangebyscoreAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously return a range of members in a sorted set, by score, with scores ordered from high to low.
static Long	zrevrangebyscoreWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Long	zrevrangebyscoreWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static List<ScoredValue<Object>>	zrevrangebyscoreWithScores(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static List<ScoredValue<Object>>	zrevrangebyscoreWithScores(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Future<Long>	zrevrangebyscoreWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Future<Long>	zrevrangebyscoreWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Future<List<ScoredValue<Object>>>	zrevrangebyscoreWithScoresAsync(String connectionName, Object key, Range<? extends Number> range, Limit limit, GloopExecutionContext context)	Asynchronously return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Future<List<ScoredValue<Object>>>	zrevrangebyscoreWithScoresAsync(String connectionName, Object key, Range<? extends Number> range, GloopExecutionContext context)	Asynchronously return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
static Long	zrevrangeWithScores(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
static List<ScoredValue<Object>>	zrevrangeWithScores(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
static Future<Long>	zrevrangeWithScoresAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
static Future<List<ScoredValue<Object>>>	zrevrangeWithScoresAsync(String connectionName, Object key, long start, long stop, GloopExecutionContext context)	Asynchronously return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
static Long	zrevrank(String connectionName, Object key, Object member, GloopExecutionContext context)	Determine the index of a member in a sorted set, with scores ordered from high to low.
static Future<Long>	zrevrankAsync(String connectionName, Object key, Object member, GloopExecutionContext context)	Asynchronously determine the index of a member in a sorted set, with scores ordered from high to low.
static StreamScanCursor	zscan(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanArgs scanArgs, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static StreamScanCursor	zscan(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, ScanArgs scanArgs, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static StreamScanCursor	zscan(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static StreamScanCursor	zscan(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static ScoredValueScanCursor<Object>	zscan(String connectionName, Object key, ScanArgs scanArgs, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static ScoredValueScanCursor<Object>	zscan(String connectionName, Object key, ScanCursor scanCursor, ScanArgs scanArgs, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static ScoredValueScanCursor<Object>	zscan(String connectionName, Object key, ScanCursor scanCursor, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static ScoredValueScanCursor<Object>	zscan(String connectionName, Object key, GloopExecutionContext context)	Incrementally iterate sorted sets elements and associated scores.
static Future<StreamScanCursor>	zscanAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanArgs scanArgs, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<StreamScanCursor>	zscanAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, ScanArgs scanArgs, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<StreamScanCursor>	zscanAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, ScanCursor scanCursor, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<StreamScanCursor>	zscanAsync(String connectionName, ScoredValueStreamingChannel<Object> channel, Object key, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<ScoredValueScanCursor<Object>>	zscanAsync(String connectionName, Object key, ScanArgs scanArgs, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<ScoredValueScanCursor<Object>>	zscanAsync(String connectionName, Object key, ScanCursor scanCursor, ScanArgs scanArgs, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<ScoredValueScanCursor<Object>>	zscanAsync(String connectionName, Object key, ScanCursor scanCursor, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Future<ScoredValueScanCursor<Object>>	zscanAsync(String connectionName, Object key, GloopExecutionContext context)	Asynchronously incrementally iterate sorted sets elements and associated scores.
static Double	zscore(String connectionName, Object key, Object member, GloopExecutionContext context)	Get the score associated with the given member in a sorted set.
static Future<Double>	zscoreAsync(String connectionName, Object key, Object member, GloopExecutionContext context)	Asynchronously get the score associated with the given member in a sorted set.
static Long	zunionstore(String connectionName, Object destination, ZStoreArgs storeArgs, GloopExecutionContext context, Object... keys)	Add multiple sorted sets and store the resulting sorted set in a new key.
static Long	zunionstore(String connectionName, Object destination, GloopExecutionContext context, Object... keys)	Add multiple sorted sets and store the resulting sorted set in a new key.
static Future<Long>	zunionstoreAsync(String connectionName, Object destination, ZStoreArgs storeArgs, GloopExecutionContext context, Object... keys)	Asynchronously add multiple sorted sets and store the resulting sorted set in a new key.
static Future<Long>	zunionstoreAsync(String connectionName, Object destination, GloopExecutionContext context, Object... keys)	Asynchronously add multiple sorted sets and store the resulting sorted set in a new key.

Methods inherited from class io.toro.martini.redis.RedisBaseMethods

getDataSourceManager, getRedisConnection, getRedisConnection

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RedisSortedSetMethods

@Autowired
RedisSortedSetMethods(io.toro.martini.database.DataSourceManager dataSourceManager)

Method Detail

bzpopmin

@GloopObjectParameter("output{\n  redisKeyValue{\n    key:object\n    value:object\n  }\n}")
public static GloopModel bzpopmin(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  long timeout,
                                  GloopExecutionContext context,
                                  @GloopParameter(allowNull=false)
                                  Object... keys)

Removes and returns a member with the lowest scores in the sorted set stored at one of the keys.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

timeout - the timeout in seconds.

keys - the keys.

Returns:

KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.

Since:

5.1

bzpopminAsync

@GloopParameter(name="redisFutureBzpopminOutput")
public static Future<KeyValue<Object,ScoredValue<Object>>> bzpopminAsync(@GloopParameter(allowNull=false)
                                                                               String connectionName,
                                                                               @GloopParameter(allowNull=false)
                                                                               long timeout,
                                                                               GloopExecutionContext context,
                                                                               @GloopParameter(allowNull=false)
                                                                               Object... keys)

Asynchronously removes and returns a member with the lowest scores in the sorted set stored at one of the keys.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

timeout - the timeout in seconds.

keys - the keys.

Returns:

keyValue<K, scoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.

Since:

5.1

bzpopmax

@GloopObjectParameter("output{\n  redisKeyValue{\n    key:object\n    value:object\n  }\n}")
public static GloopModel bzpopmax(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  long timeout,
                                  GloopExecutionContext context,
                                  @GloopParameter(allowNull=false)
                                  Object... keys)

Removes and returns a member with the highest scores in the sorted set stored at one of the keys.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

timeout - the timeout in seconds.

keys - the keys.

Returns:

KeyValue<K, ScoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.

Since:

5.1

bzpopmaxAsync

@GloopParameter(name="redisFutureBzpopmaxOutput")
public static Future<KeyValue<Object,ScoredValue<Object>>> bzpopmaxAsync(@GloopParameter(allowNull=false)
                                                                               String connectionName,
                                                                               @GloopParameter(allowNull=false)
                                                                               long timeout,
                                                                               GloopExecutionContext context,
                                                                               @GloopParameter(allowNull=false)
                                                                               Object... keys)

Asynchronously removes and returns a member with the highest scores in the sorted set stored at one of the keys.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

timeout - the timeout in seconds.

keys - the keys.

Returns:

keyValue<K, scoredValue<V>> multi-bulk containing the name of the key, the score and the popped member.

Since:

5.1

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        @GloopParameter(allowNull=false)
                        double score,
                        @GloopParameter(allowNull=false)
                        Object member,
                        GloopExecutionContext context)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

score - the score

member - the member

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        GloopExecutionContext context,
                        @GloopParameter(allowNull=false)
                        Object... scoresAndValues)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        GloopExecutionContext context,
                        @GloopParameter(allowNull=false)
                        ScoredValue<Object>... scoredValues)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scoredValues - the scored values

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        @GloopParameter(allowNull=false)
                        ZAddArgs zaddArgs,
                        @GloopParameter(allowNull=false)
                        double score,
                        @GloopParameter(allowNull=false)
                        Object member,
                        GloopExecutionContext context)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

score - the score

member - the member

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        @GloopParameter(allowNull=false)
                        ZAddArgs zaddArgs,
                        GloopExecutionContext context,
                        @GloopParameter(allowNull=false)
                        Object... scoresAndValues)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zadd

@GloopParameter(name="redisZaddOutput")
public static Long zadd(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        @GloopParameter(allowNull=false)
                        ZAddArgs zaddArgs,
                        GloopExecutionContext context,
                        @GloopParameter(allowNull=false)
                        ScoredValue<Object>... scoredValues)

Add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the ke

zaddArgs - arguments for zadd

scoredValues - the scored values

Returns:

Long integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     double score,
                                     @GloopParameter(allowNull=false)
                                     Object member,
                                     GloopExecutionContext context)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

score - the score

member - the member

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context,
                                     @GloopParameter(allowNull=false)
                                     Object... scoresAndValues)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context,
                                     @GloopParameter(allowNull=false)
                                     ScoredValue<Object>... scoredValues)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scoredValues - the scored values

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ZAddArgs zaddArgs,
                                     @GloopParameter(allowNull=false)
                                     double score,
                                     @GloopParameter(allowNull=false)
                                     Object member,
                                     GloopExecutionContext context)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

score - the score

member - the member

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ZAddArgs zaddArgs,
                                     GloopExecutionContext context,
                                     @GloopParameter(allowNull=false)
                                     Object... scoresAndValues)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddAsync

@GloopParameter(name="redisFutureZaddOutput")
public static Future<Long> zaddAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ZAddArgs zaddArgs,
                                     GloopExecutionContext context,
                                     @GloopParameter(allowNull=false)
                                     ScoredValue<Object>... scoredValues)

Asynchronously add one or more members to a sorted set, or update its score if it already exists.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the ke

zaddArgs - arguments for zadd

scoredValues - the scored values

Returns:

long integer-reply specifically: the number of elements added to the sorted sets, not including elements already existing for which the score was updated.

zaddincr

@GloopParameter(name="redisZaddincrOutput")
public static Double zaddincr(@GloopParameter(allowNull=false)
                              String connectionName,
                              @GloopParameter(allowNull=false)
                              Object key,
                              @GloopParameter(allowNull=false)
                              double score,
                              @GloopParameter(allowNull=false)
                              Object member,
                              GloopExecutionContext context)

Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

score - the score

member - the member

Returns:

Long integer-reply specifically: The total number of elements changed

zaddincr

@GloopParameter(name="redisZaddincrOutput")
public static Double zaddincr(@GloopParameter(allowNull=false)
                              String connectionName,
                              @GloopParameter(allowNull=false)
                              Object key,
                              @GloopParameter(allowNull=false)
                              ZAddArgs zaddArgs,
                              @GloopParameter(allowNull=false)
                              double score,
                              @GloopParameter(allowNull=false)
                              Object member,
                              GloopExecutionContext context)

Add one or more members to a sorted set, or update its score if it already exists applying the INCR option. ZADD acts like ZINCRBY.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

score - the score

member - the member

Returns:

Long integer-reply specifically: The total number of elements changed

Since:

4.3

zaddincrAsync

@GloopParameter(name="redisFutureZaddincrOutput")
public static Future<Double> zaddincrAsync(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           @GloopParameter(allowNull=false)
                                           double score,
                                           @GloopParameter(allowNull=false)
                                           Object member,
                                           GloopExecutionContext context)

Asynchronously add one or more members to a sorted set, or update its score if it already exists applying the iNCR option. zADD acts like zINCRBY.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

score - the score

member - the member

Returns:

long integer-reply specifically: the total number of elements changed

zaddincrAsync

@GloopParameter(name="redisFutureZaddincrOutput")
public static Future<Double> zaddincrAsync(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           @GloopParameter(allowNull=false)
                                           ZAddArgs zaddArgs,
                                           @GloopParameter(allowNull=false)
                                           double score,
                                           @GloopParameter(allowNull=false)
                                           Object member,
                                           GloopExecutionContext context)

Asynchronously add one or more members to a sorted set, or update its score if it already exists applying the iNCR option. zADD acts like zINCRBY.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

zaddArgs - arguments for zadd

score - the score

member - the member

Returns:

long integer-reply specifically: the total number of elements changed

Since:

4.3

zcard

@GloopParameter(name="redisZcardOutput")
public static Long zcard(@GloopParameter(allowNull=false)
                         String connectionName,
                         @GloopParameter(allowNull=false)
                         Object key,
                         GloopExecutionContext context)

Get the number of members in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

Long integer-reply the cardinality (number of elements) of the sorted set, or false if key does not exist.

zcardAsync

@GloopParameter(name="redisFutureZcardOutput")
public static Future<Long> zcardAsync(@GloopParameter(allowNull=false)
                                      String connectionName,
                                      @GloopParameter(allowNull=false)
                                      Object key,
                                      GloopExecutionContext context)

Asynchronously get the number of members in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

long integer-reply the cardinality (number of elements) of the sorted set, or false if key does not exist.

zcount

@GloopParameter(name="redisZcountOutput")
public static Long zcount(@GloopParameter(allowNull=false)
                          String connectionName,
                          @GloopParameter(allowNull=false)
                          Object key,
                          @GloopParameter(allowNull=false)
                          Range<? extends Number> range,
                          GloopExecutionContext context)

Count the members in a sorted set with scores within the given Range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

Long integer-reply the number of elements in the specified score range.

Since:

4.3

zcountAsync

@GloopParameter(name="redisFutureZcountOutput")
public static Future<Long> zcountAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       @GloopParameter(allowNull=false)
                                       Range<? extends Number> range,
                                       GloopExecutionContext context)

Asynchronously count the members in a sorted set with scores within the given Range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

long integer-reply the number of elements in the specified score range.

Since:

4.3

zincrby

@GloopParameter(name="redisZincrbyOutput")
public static Double zincrby(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             double amount,
                             @GloopParameter(allowNull=false)
                             Object member,
                             GloopExecutionContext context)

Increment the score of a member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

amount - the increment type: long

member - the member type: value

Returns:

Double bulk-string-reply the new score of member (a double precision floating point number), represented as string.

zincrbyAsync

@GloopParameter(name="redisFutureZincrbyOutput")
public static Future<Double> zincrbyAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          double amount,
                                          @GloopParameter(allowNull=false)
                                          Object member,
                                          GloopExecutionContext context)

Asynchronously increment the score of a member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

amount - the increment type: long

member - the member type: value

Returns:

double bulk-string-reply the new score of member (a double precision floating point number), represented as string.

zinterstore

@GloopParameter(name="redisZinterstoreOutput")
public static Long zinterstore(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object destination,
                               GloopExecutionContext context,
                               @GloopParameter(allowNull=false)
                               Object... keys)

Intersect multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

keys - the keys

Returns:

Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore

@GloopParameter(name="redisZinterstoreOutput")
public static Long zinterstore(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object destination,
                               @GloopParameter(allowNull=false)
                               ZStoreArgs storeArgs,
                               GloopExecutionContext context,
                               @GloopParameter(allowNull=false)
                               Object... keys)

Intersect multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

storeArgs - the storeArgs

keys - the keys

Returns:

Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstoreAsync

@GloopParameter(name="redisFutureZinterstoreOutput")
public static Future<Long> zinterstoreAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object destination,
                                            GloopExecutionContext context,
                                            @GloopParameter(allowNull=false)
                                            Object... keys)

Asynchronously intersect multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

keys - the keys

Returns:

long integer-reply the number of elements in the resulting sorted set at destination.

zinterstoreAsync

@GloopParameter(name="redisFutureZinterstoreOutput")
public static Future<Long> zinterstoreAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object destination,
                                            @GloopParameter(allowNull=false)
                                            ZStoreArgs storeArgs,
                                            GloopExecutionContext context,
                                            @GloopParameter(allowNull=false)
                                            Object... keys)

Asynchronously intersect multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

storeArgs - the storeArgs

keys - the keys

Returns:

long integer-reply the number of elements in the resulting sorted set at destination.

zlexcount

@GloopParameter(name="redisZlexcountOutput")
public static Long zlexcount(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             Range<Object> range,
                             GloopExecutionContext context)

Count the number of members in a sorted set between a given lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

Long integer-reply the number of elements in the specified score range.

Since:

4.3

zlexcountAsync

@GloopParameter(name="redisFutureZlexcountOutput")
public static Future<Long> zlexcountAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          Range<Object> range,
                                          GloopExecutionContext context)

Asynchronously count the number of members in a sorted set between a given lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

long integer-reply the number of elements in the specified score range.

Since:

4.3

zpopmin

@GloopParameter(name="redisZpopminOutput")
public static ScoredValue<Object> zpopmin(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          GloopExecutionContext context)

Removes and returns up to count members with the lowest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

ScoredValue<V> the removed element.

Since:

5.1

zpopmin

@GloopParameter(name="redisZpopminOutput")
public static List<ScoredValue<Object>> zpopmin(@GloopParameter(allowNull=false)
                                                String connectionName,
                                                @GloopParameter(allowNull=false)
                                                Object key,
                                                @GloopParameter(allowNull=false)
                                                long count,
                                                GloopExecutionContext context)

Removes and returns up to count members with the lowest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key.

count - the number of elements to return.

Returns:

List<ScoredValue<V>> array-reply list of popped scores and elements.

Since:

5.1

zpopminAsync

@GloopParameter(name="redisFutureZpopminOutput")
public static Future<ScoredValue<Object>> zpopminAsync(@GloopParameter(allowNull=false)
                                                       String connectionName,
                                                       @GloopParameter(allowNull=false)
                                                       Object key,
                                                       GloopExecutionContext context)

Asynchronously removes and returns up to count members with the lowest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

scoredValue<V> the removed element.

Since:

5.1

zpopminAsync

@GloopParameter(name="redisFutureZpopminOutput")
public static Future<List<ScoredValue<Object>>> zpopminAsync(@GloopParameter(allowNull=false)
                                                             String connectionName,
                                                             @GloopParameter(allowNull=false)
                                                             Object key,
                                                             @GloopParameter(allowNull=false)
                                                             long count,
                                                             GloopExecutionContext context)

Asynchronously removes and returns up to count members with the lowest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key.

count - the number of elements to return.

Returns:

list<ScoredValue<V>> array-reply list of popped scores and elements.

Since:

5.1

zpopmax

@GloopParameter(name="redisZpopmaxOutput")
public static ScoredValue<Object> zpopmax(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          GloopExecutionContext context)

Removes and returns up to count members with the highest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

ScoredValue<V> the removed element.

Since:

5.1

zpopmax

@GloopParameter(name="redisZpopmaxOutput")
public static List<ScoredValue<Object>> zpopmax(@GloopParameter(allowNull=false)
                                                String connectionName,
                                                @GloopParameter(allowNull=false)
                                                Object key,
                                                @GloopParameter(allowNull=false)
                                                long count,
                                                GloopExecutionContext context)

Removes and returns up to count members with the highest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key.

count - the number of elements to return.

Returns:

List<ScoredValue<V>> array-reply list of popped scores and elements.

Since:

5.1

zpopmaxAsync

@GloopParameter(name="redisFutureZpopmaxOutput")
public static Future<ScoredValue<Object>> zpopmaxAsync(@GloopParameter(allowNull=false)
                                                       String connectionName,
                                                       @GloopParameter(allowNull=false)
                                                       Object key,
                                                       GloopExecutionContext context)

Asynchronously removes and returns up to count members with the highest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

scoredValue<V> the removed element.

Since:

5.1

zpopmaxAsync

@GloopParameter(name="redisFutureZpopmaxOutput")
public static Future<List<ScoredValue<Object>>> zpopmaxAsync(@GloopParameter(allowNull=false)
                                                             String connectionName,
                                                             @GloopParameter(allowNull=false)
                                                             Object key,
                                                             @GloopParameter(allowNull=false)
                                                             long count,
                                                             GloopExecutionContext context)

Asynchronously removes and returns up to count members with the highest scores in the sorted set stored at key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key.

count - the number of elements to return.

Returns:

list<ScoredValue<V>> array-reply list of popped scores and elements.

Since:

5.1

zrange

@GloopParameter(name="redisZrangeOutput")
public static Long zrange(@GloopParameter(allowNull=false)
                          String connectionName,
                          @GloopParameter(allowNull=false)
                          ValueStreamingChannel<Object> channel,
                          @GloopParameter(allowNull=false)
                          Object key,
                          @GloopParameter(allowNull=false)
                          long start,
                          @GloopParameter(allowNull=false)
                          long stop,
                          GloopExecutionContext context)

Return a range of members in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

start - the start

stop - the stop

Returns:

Long count of elements in the specified range.

zrange

@GloopParameter(name="redisZrangeOutput")
public static List<Object> zrange(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  Object key,
                                  @GloopParameter(allowNull=false)
                                  long start,
                                  @GloopParameter(allowNull=false)
                                  long stop,
                                  GloopExecutionContext context)

Return a range of members in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

List<V> array-reply list of elements in the specified range.

zrangeAsync

@GloopParameter(name="redisFutureZrangeOutput")
public static Future<List<Object>> zrangeAsync(@GloopParameter(allowNull=false)
                                               String connectionName,
                                               @GloopParameter(allowNull=false)
                                               Object key,
                                               @GloopParameter(allowNull=false)
                                               long start,
                                               @GloopParameter(allowNull=false)
                                               long stop,
                                               GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

list<V> array-reply list of elements in the specified range.

zrangeAsync

@GloopParameter(name="redisFutureZrangeOutput")
public static Future<Long> zrangeAsync(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       ValueStreamingChannel<Object> channel,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       @GloopParameter(allowNull=false)
                                       long start,
                                       @GloopParameter(allowNull=false)
                                       long stop,
                                       GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

start - the start

stop - the stop

Returns:

long count of elements in the specified range.

zrangeWithScores

@GloopParameter(name="redisZrangeWithScoresOutput")
public static List<ScoredValue<Object>> zrangeWithScores(@GloopParameter(allowNull=false)
                                                         String connectionName,
                                                         @GloopParameter(allowNull=false)
                                                         Object key,
                                                         @GloopParameter(allowNull=false)
                                                         long start,
                                                         @GloopParameter(allowNull=false)
                                                         long stop,
                                                         GloopExecutionContext context)

Return a range of members with scores in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

List<V> array-reply list of elements in the specified range.

zrangeWithScores

@GloopParameter(name="redisZrangeWithScoresOutput")
public static Long zrangeWithScores(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    ScoredValueStreamingChannel<Object> channel,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    @GloopParameter(allowNull=false)
                                    long start,
                                    @GloopParameter(allowNull=false)
                                    long stop,
                                    GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

start - the start

stop - the stop

Returns:

Long count of elements in the specified range.

zrangeWithScoresAsync

@GloopParameter(name="redisFutureZrangeWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrangeWithScoresAsync(@GloopParameter(allowNull=false)
                                                                      String connectionName,
                                                                      @GloopParameter(allowNull=false)
                                                                      Object key,
                                                                      @GloopParameter(allowNull=false)
                                                                      long start,
                                                                      @GloopParameter(allowNull=false)
                                                                      long stop,
                                                                      GloopExecutionContext context)

Asynchronously return a range of members with scores in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

list<V> array-reply list of elements in the specified range.

zrangeWithScoresAsync

@GloopParameter(name="redisFutureZrangeWithScoresOutput")
public static Future<Long> zrangeWithScoresAsync(@GloopParameter(allowNull=false)
                                                 String connectionName,
                                                 @GloopParameter(allowNull=false)
                                                 ScoredValueStreamingChannel<Object> channel,
                                                 @GloopParameter(allowNull=false)
                                                 Object key,
                                                 @GloopParameter(allowNull=false)
                                                 long start,
                                                 @GloopParameter(allowNull=false)
                                                 long stop,
                                                 GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by index.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

start - the start

stop - the stop

Returns:

long count of elements in the specified range.

zrangebylex

@GloopParameter(name="redisZrangebylexOutput")
public static List<Object> zrangebylex(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       @GloopParameter(allowNull=false)
                                       Range<Object> range,
                                       GloopExecutionContext context)

Return a range of members in a sorted set, by lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<V> array-reply list of elements in the specified range.

Since:

4.3

zrangebylex

@GloopParameter(name="redisZrangebylexOutput")
public static List<Object> zrangebylex(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       @GloopParameter(allowNull=false)
                                       Range<Object> range,
                                       @GloopParameter(allowNull=false)
                                       Limit limit,
                                       GloopExecutionContext context)

Return a range of members in a sorted set, by lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

List<V> array-reply list of elements in the specified range.

Since:

4.3

zrangebylexAsync

@GloopParameter(name="redisFutureZrangebylexOutput")
public static Future<List<Object>> zrangebylexAsync(@GloopParameter(allowNull=false)
                                                    String connectionName,
                                                    @GloopParameter(allowNull=false)
                                                    Object key,
                                                    @GloopParameter(allowNull=false)
                                                    Range<Object> range,
                                                    GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<V> array-reply list of elements in the specified range.

Since:

4.3

zrangebylexAsync

@GloopParameter(name="redisFutureZrangebylexOutput")
public static Future<List<Object>> zrangebylexAsync(@GloopParameter(allowNull=false)
                                                    String connectionName,
                                                    @GloopParameter(allowNull=false)
                                                    Object key,
                                                    @GloopParameter(allowNull=false)
                                                    Range<Object> range,
                                                    @GloopParameter(allowNull=false)
                                                    Limit limit,
                                                    GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

list<V> array-reply list of elements in the specified range.

Since:

4.3

zrangebyscore

@GloopParameter(name="redisZrangebyscoreOutput")
public static List<Object> zrangebyscore(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         Object key,
                                         @GloopParameter(allowNull=false)
                                         Range<? extends Number> range,
                                         GloopExecutionContext context)

Return a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscore

@GloopParameter(name="redisZrangebyscoreOutput")
public static List<Object> zrangebyscore(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         Object key,
                                         @GloopParameter(allowNull=false)
                                         Range<? extends Number> range,
                                         @GloopParameter(allowNull=false)
                                         Limit limit,
                                         GloopExecutionContext context)

Return a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscore

@GloopParameter(name="redisZrangebyscoreOutput")
public static Long zrangebyscore(@GloopParameter(allowNull=false)
                                 String connectionName,
                                 @GloopParameter(allowNull=false)
                                 ValueStreamingChannel<Object> channel,
                                 @GloopParameter(allowNull=false)
                                 Object key,
                                 @GloopParameter(allowNull=false)
                                 Range<? extends Number> range,
                                 GloopExecutionContext context)

Stream over a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

Returns:

Long count of elements in the specified score range.

Since:

4.3

zrangebyscore

@GloopParameter(name="redisZrangebyscoreOutput")
public static Long zrangebyscore(@GloopParameter(allowNull=false)
                                 String connectionName,
                                 @GloopParameter(allowNull=false)
                                 ValueStreamingChannel<Object> channel,
                                 @GloopParameter(allowNull=false)
                                 Object key,
                                 @GloopParameter(allowNull=false)
                                 Range<? extends Number> range,
                                 @GloopParameter(allowNull=false)
                                 Limit limit,
                                 GloopExecutionContext context)

Stream over a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

limit - the limit

Returns:

Long count of elements in the specified score range.

Since:

4.3

zrangebyscoreAsync

@GloopParameter(name="redisFutureZrangebyscoreOutput")
public static Future<List<Object>> zrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                      String connectionName,
                                                      @GloopParameter(allowNull=false)
                                                      Object key,
                                                      @GloopParameter(allowNull=false)
                                                      Range<? extends Number> range,
                                                      GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreAsync

@GloopParameter(name="redisFutureZrangebyscoreOutput")
public static Future<List<Object>> zrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                      String connectionName,
                                                      @GloopParameter(allowNull=false)
                                                      Object key,
                                                      @GloopParameter(allowNull=false)
                                                      Range<? extends Number> range,
                                                      @GloopParameter(allowNull=false)
                                                      Limit limit,
                                                      GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreAsync

@GloopParameter(name="redisFutureZrangebyscoreOutput")
public static Future<Long> zrangebyscoreAsync(@GloopParameter(allowNull=false)
                                              String connectionName,
                                              @GloopParameter(allowNull=false)
                                              ValueStreamingChannel<Object> channel,
                                              @GloopParameter(allowNull=false)
                                              Object key,
                                              @GloopParameter(allowNull=false)
                                              Range<? extends Number> range,
                                              GloopExecutionContext context)

Asynchronously stream over a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

Returns:

long count of elements in the specified score range.

Since:

4.3

zrangebyscoreAsync

@GloopParameter(name="redisFutureZrangebyscoreOutput")
public static Future<Long> zrangebyscoreAsync(@GloopParameter(allowNull=false)
                                              String connectionName,
                                              @GloopParameter(allowNull=false)
                                              ValueStreamingChannel<Object> channel,
                                              @GloopParameter(allowNull=false)
                                              Object key,
                                              @GloopParameter(allowNull=false)
                                              Range<? extends Number> range,
                                              @GloopParameter(allowNull=false)
                                              Limit limit,
                                              GloopExecutionContext context)

Asynchronously stream over a range of members in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

limit - the limit

Returns:

long count of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScores

@GloopParameter(name="redisZrangebyscoreWithScoresOutput")
public static List<ScoredValue<Object>> zrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                                                String connectionName,
                                                                @GloopParameter(allowNull=false)
                                                                Object key,
                                                                @GloopParameter(allowNull=false)
                                                                Range<? extends Number> range,
                                                                GloopExecutionContext context)

Return a range of members with score in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScores

@GloopParameter(name="redisZrangebyscoreWithScoresOutput")
public static List<ScoredValue<Object>> zrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                                                String connectionName,
                                                                @GloopParameter(allowNull=false)
                                                                Object key,
                                                                @GloopParameter(allowNull=false)
                                                                Range<? extends Number> range,
                                                                @GloopParameter(allowNull=false)
                                                                Limit limit,
                                                                GloopExecutionContext context)

Return a range of members with score in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

List<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScores

@GloopParameter(name="redisZrangebyscoreWithScoresOutput")
public static Long zrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           ScoredValueStreamingChannel<Object> channel,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           @GloopParameter(allowNull=false)
                                           Range<? extends Number> range,
                                           GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

Returns:

Long count of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScores

@GloopParameter(name="redisZrangebyscoreWithScoresOutput")
public static Long zrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                           String connectionName,
                                           @GloopParameter(allowNull=false)
                                           ScoredValueStreamingChannel<Object> channel,
                                           @GloopParameter(allowNull=false)
                                           Object key,
                                           @GloopParameter(allowNull=false)
                                           Range<? extends Number> range,
                                           @GloopParameter(allowNull=false)
                                           Limit limit,
                                           GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

limit - the limit

Returns:

Long count of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrangebyscoreWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                                             String connectionName,
                                                                             @GloopParameter(allowNull=false)
                                                                             Object key,
                                                                             @GloopParameter(allowNull=false)
                                                                             Range<? extends Number> range,
                                                                             GloopExecutionContext context)

Asynchronously return a range of members with score in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrangebyscoreWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                                             String connectionName,
                                                                             @GloopParameter(allowNull=false)
                                                                             Object key,
                                                                             @GloopParameter(allowNull=false)
                                                                             Range<? extends Number> range,
                                                                             @GloopParameter(allowNull=false)
                                                                             Limit limit,
                                                                             GloopExecutionContext context)

Asynchronously return a range of members with score in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

list<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrangebyscoreWithScoresOutput")
public static Future<Long> zrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                        String connectionName,
                                                        @GloopParameter(allowNull=false)
                                                        ScoredValueStreamingChannel<Object> channel,
                                                        @GloopParameter(allowNull=false)
                                                        Object key,
                                                        @GloopParameter(allowNull=false)
                                                        Range<? extends Number> range,
                                                        GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

Returns:

long count of elements in the specified score range.

Since:

4.3

zrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrangebyscoreWithScoresOutput")
public static Future<Long> zrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                        String connectionName,
                                                        @GloopParameter(allowNull=false)
                                                        ScoredValueStreamingChannel<Object> channel,
                                                        @GloopParameter(allowNull=false)
                                                        Object key,
                                                        @GloopParameter(allowNull=false)
                                                        Range<? extends Number> range,
                                                        @GloopParameter(allowNull=false)
                                                        Limit limit,
                                                        GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by score.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

limit - the limit

Returns:

long count of elements in the specified score range.

Since:

4.3

zrank

@GloopParameter(name="redisZrankOutput")
public static Long zrank(@GloopParameter(allowNull=false)
                         String connectionName,
                         @GloopParameter(allowNull=false)
                         Object key,
                         @GloopParameter(allowNull=false)
                         Object member,
                         GloopExecutionContext context)

Determine the index of a member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,

zrankAsync

@GloopParameter(name="redisFutureZrankOutput")
public static Future<Long> zrankAsync(@GloopParameter(allowNull=false)
                                      String connectionName,
                                      @GloopParameter(allowNull=false)
                                      Object key,
                                      @GloopParameter(allowNull=false)
                                      Object member,
                                      GloopExecutionContext context)

Asynchronously determine the index of a member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

long integer-reply the rank of member. if member does not exist in the sorted set or key does not exist,

zrem

@GloopParameter(name="redisZremOutput")
public static Long zrem(@GloopParameter(allowNull=false)
                        String connectionName,
                        @GloopParameter(allowNull=false)
                        Object key,
                        GloopExecutionContext context,
                        @GloopParameter(allowNull=false)
                        Object... members)

Remove one or more members from a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

members - the member type: value

Returns:

Long integer-reply specifically: The number of members removed from the sorted set, not including non existing members.

zremAsync

@GloopParameter(name="redisFutureZremOutput")
public static Future<Long> zremAsync(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context,
                                     @GloopParameter(allowNull=false)
                                     Object... members)

Asynchronously remove one or more members from a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

members - the member type: value

Returns:

long integer-reply specifically: the number of members removed from the sorted set, not including non existing members.

zremrangebylex

@GloopParameter(name="redisZremrangebylexOutput")
public static Long zremrangebylex(@GloopParameter(allowNull=false)
                                  String connectionName,
                                  @GloopParameter(allowNull=false)
                                  Object key,
                                  @GloopParameter(allowNull=false)
                                  Range<Object> range,
                                  GloopExecutionContext context)

Remove all members in a sorted set between the given lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

Long integer-reply the number of elements removed.

Since:

4.3

zremrangebylexAsync

@GloopParameter(name="redisFutureZremrangebylexOutput")
public static Future<Long> zremrangebylexAsync(@GloopParameter(allowNull=false)
                                               String connectionName,
                                               @GloopParameter(allowNull=false)
                                               Object key,
                                               @GloopParameter(allowNull=false)
                                               Range<Object> range,
                                               GloopExecutionContext context)

Asynchronously remove all members in a sorted set between the given lexicographical range.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

long integer-reply the number of elements removed.

Since:

4.3

zremrangebyrank

@GloopParameter(name="redisZremrangebyrankOutput")
public static Long zremrangebyrank(@GloopParameter(allowNull=false)
                                   String connectionName,
                                   @GloopParameter(allowNull=false)
                                   Object key,
                                   @GloopParameter(allowNull=false)
                                   long start,
                                   @GloopParameter(allowNull=false)
                                   long stop,
                                   GloopExecutionContext context)

Remove all members in a sorted set within the given indexes.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start type: long

stop - the stop type: long

Returns:

Long integer-reply the number of elements removed.

zremrangebyscore

@GloopParameter(name="redisZremrangebyscoreOutput")
public static Long zremrangebyscore(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    @GloopParameter(allowNull=false)
                                    Range<? extends Number> range,
                                    GloopExecutionContext context)

Remove all members in a sorted set within the given scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

Long integer-reply the number of elements removed.

Since:

4.3

zremrangebyrankAsync

@GloopParameter(name="redisFutureZremrangebyrankOutput")
public static Future<Long> zremrangebyrankAsync(@GloopParameter(allowNull=false)
                                                String connectionName,
                                                @GloopParameter(allowNull=false)
                                                Object key,
                                                @GloopParameter(allowNull=false)
                                                long start,
                                                @GloopParameter(allowNull=false)
                                                long stop,
                                                GloopExecutionContext context)

Asynchronously remove all members in a sorted set within the given indexes.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start type: long

stop - the stop type: long

Returns:

long integer-reply the number of elements removed.

zremrangebyscoreAsync

@GloopParameter(name="redisFutureZremrangebyscoreOutput")
public static Future<Long> zremrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                 String connectionName,
                                                 @GloopParameter(allowNull=false)
                                                 Object key,
                                                 @GloopParameter(allowNull=false)
                                                 Range<? extends Number> range,
                                                 GloopExecutionContext context)

Asynchronously remove all members in a sorted set within the given scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

long integer-reply the number of elements removed.

Since:

4.3

zrevrange

@GloopParameter(name="redisZrevrangeOutput")
public static List<Object> zrevrange(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     long start,
                                     @GloopParameter(allowNull=false)
                                     long stop,
                                     GloopExecutionContext context)

Return a range of members in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

List<V> array-reply list of elements in the specified range.

zrevrange

@GloopParameter(name="redisZrevrangeOutput")
public static Long zrevrange(@GloopParameter(allowNull=false)
                             String connectionName,
                             @GloopParameter(allowNull=false)
                             ValueStreamingChannel<Object> channel,
                             @GloopParameter(allowNull=false)
                             Object key,
                             @GloopParameter(allowNull=false)
                             long start,
                             @GloopParameter(allowNull=false)
                             long stop,
                             GloopExecutionContext context)

Stream over a range of members in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

start - the start

stop - the stop

Returns:

Long count of elements in the specified range.

zrevrangeAsync

@GloopParameter(name="redisFutureZrevrangeOutput")
public static Future<List<Object>> zrevrangeAsync(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  long start,
                                                  @GloopParameter(allowNull=false)
                                                  long stop,
                                                  GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

list<V> array-reply list of elements in the specified range.

zrevrangeAsync

@GloopParameter(name="redisFutureZrevrangeOutput")
public static Future<Long> zrevrangeAsync(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          ValueStreamingChannel<Object> channel,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          long start,
                                          @GloopParameter(allowNull=false)
                                          long stop,
                                          GloopExecutionContext context)

Asynchronously stream over a range of members in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

start - the start

stop - the stop

Returns:

long count of elements in the specified range.

zrevrangeWithScores

@GloopParameter(name="redisZrevrangeWithScoresOutput")
public static List<ScoredValue<Object>> zrevrangeWithScores(@GloopParameter(allowNull=false)
                                                            String connectionName,
                                                            @GloopParameter(allowNull=false)
                                                            Object key,
                                                            @GloopParameter(allowNull=false)
                                                            long start,
                                                            @GloopParameter(allowNull=false)
                                                            long stop,
                                                            GloopExecutionContext context)

Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

List<V> array-reply list of elements in the specified range.

zrevrangeWithScores

@GloopParameter(name="redisZrevrangeWithScoresOutput")
public static Long zrevrangeWithScores(@GloopParameter(allowNull=false)
                                       String connectionName,
                                       @GloopParameter(allowNull=false)
                                       ScoredValueStreamingChannel<Object> channel,
                                       @GloopParameter(allowNull=false)
                                       Object key,
                                       @GloopParameter(allowNull=false)
                                       long start,
                                       @GloopParameter(allowNull=false)
                                       long stop,
                                       GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

start - the start

stop - the stop

Returns:

Long count of elements in the specified range.

zrevrangeWithScoresAsync

@GloopParameter(name="redisFutureZrevrangeWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrevrangeWithScoresAsync(@GloopParameter(allowNull=false)
                                                                         String connectionName,
                                                                         @GloopParameter(allowNull=false)
                                                                         Object key,
                                                                         @GloopParameter(allowNull=false)
                                                                         long start,
                                                                         @GloopParameter(allowNull=false)
                                                                         long stop,
                                                                         GloopExecutionContext context)

Asynchronously return a range of members with scores in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

start - the start

stop - the stop

Returns:

list<V> array-reply list of elements in the specified range.

zrevrangeWithScoresAsync

@GloopParameter(name="redisFutureZrevrangeWithScoresOutput")
public static Future<Long> zrevrangeWithScoresAsync(@GloopParameter(allowNull=false)
                                                    String connectionName,
                                                    @GloopParameter(allowNull=false)
                                                    ScoredValueStreamingChannel<Object> channel,
                                                    @GloopParameter(allowNull=false)
                                                    Object key,
                                                    @GloopParameter(allowNull=false)
                                                    long start,
                                                    @GloopParameter(allowNull=false)
                                                    long stop,
                                                    GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

start - the start

stop - the stop

Returns:

long count of elements in the specified range.

zrevrangebylex

@GloopParameter(name="redisZrevrangebylexOutput")
public static List<Object> zrevrangebylex(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          Range<Object> range,
                                          GloopExecutionContext context)

Return a range of members in a sorted set, by lexicographical range ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebylex

@GloopParameter(name="redisZrevrangebylexOutput")
public static List<Object> zrevrangebylex(@GloopParameter(allowNull=false)
                                          String connectionName,
                                          @GloopParameter(allowNull=false)
                                          Object key,
                                          @GloopParameter(allowNull=false)
                                          Range<Object> range,
                                          @GloopParameter(allowNull=false)
                                          Limit limit,
                                          GloopExecutionContext context)

Return a range of members in a sorted set, by lexicographical range ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebylexAsync

@GloopParameter(name="redisFutureZrevrangebylexOutput")
public static Future<List<Object>> zrevrangebylexAsync(@GloopParameter(allowNull=false)
                                                       String connectionName,
                                                       @GloopParameter(allowNull=false)
                                                       Object key,
                                                       @GloopParameter(allowNull=false)
                                                       Range<Object> range,
                                                       GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by lexicographical range ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebylexAsync

@GloopParameter(name="redisFutureZrevrangebylexOutput")
public static Future<List<Object>> zrevrangebylexAsync(@GloopParameter(allowNull=false)
                                                       String connectionName,
                                                       @GloopParameter(allowNull=false)
                                                       Object key,
                                                       @GloopParameter(allowNull=false)
                                                       Range<Object> range,
                                                       @GloopParameter(allowNull=false)
                                                       Limit limit,
                                                       GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by lexicographical range ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscore

@GloopParameter(name="redisZrevrangebyscoreOutput")
public static List<Object> zrevrangebyscore(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object key,
                                            @GloopParameter(allowNull=false)
                                            Range<? extends Number> range,
                                            GloopExecutionContext context)

Return a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscore

@GloopParameter(name="redisZrevrangebyscoreOutput")
public static List<Object> zrevrangebyscore(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object key,
                                            @GloopParameter(allowNull=false)
                                            Range<? extends Number> range,
                                            @GloopParameter(allowNull=false)
                                            Limit limit,
                                            GloopExecutionContext context)

Return a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscore

@GloopParameter(name="redisZrevrangebyscoreOutput")
public static Long zrevrangebyscore(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    ValueStreamingChannel<Object> channel,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    @GloopParameter(allowNull=false)
                                    Range<? extends Number> range,
                                    GloopExecutionContext context)

Stream over a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

Returns:

Long count of elements in the specified range.

Since:

4.3

zrevrangebyscore

@GloopParameter(name="redisZrevrangebyscoreOutput")
public static Long zrevrangebyscore(@GloopParameter(allowNull=false)
                                    String connectionName,
                                    @GloopParameter(allowNull=false)
                                    ValueStreamingChannel<Object> channel,
                                    @GloopParameter(allowNull=false)
                                    Object key,
                                    @GloopParameter(allowNull=false)
                                    Range<? extends Number> range,
                                    @GloopParameter(allowNull=false)
                                    Limit limit,
                                    GloopExecutionContext context)

Stream over a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

limit - the limit

Returns:

Long count of elements in the specified range.

Since:

4.3

zrevrangebyscoreAsync

@GloopParameter(name="redisFutureZrevrangebyscoreOutput")
public static Future<List<Object>> zrevrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                         String connectionName,
                                                         @GloopParameter(allowNull=false)
                                                         Object key,
                                                         @GloopParameter(allowNull=false)
                                                         Range<? extends Number> range,
                                                         GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreAsync

@GloopParameter(name="redisFutureZrevrangebyscoreOutput")
public static Future<List<Object>> zrevrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                         String connectionName,
                                                         @GloopParameter(allowNull=false)
                                                         Object key,
                                                         @GloopParameter(allowNull=false)
                                                         Range<? extends Number> range,
                                                         @GloopParameter(allowNull=false)
                                                         Limit limit,
                                                         GloopExecutionContext context)

Asynchronously return a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - the limit

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreAsync

@GloopParameter(name="redisFutureZrevrangebyscoreOutput")
public static Future<Long> zrevrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                 String connectionName,
                                                 @GloopParameter(allowNull=false)
                                                 ValueStreamingChannel<Object> channel,
                                                 @GloopParameter(allowNull=false)
                                                 Object key,
                                                 @GloopParameter(allowNull=false)
                                                 Range<? extends Number> range,
                                                 GloopExecutionContext context)

Asynchronously stream over a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

Returns:

long count of elements in the specified range.

Since:

4.3

zrevrangebyscoreAsync

@GloopParameter(name="redisFutureZrevrangebyscoreOutput")
public static Future<Long> zrevrangebyscoreAsync(@GloopParameter(allowNull=false)
                                                 String connectionName,
                                                 @GloopParameter(allowNull=false)
                                                 ValueStreamingChannel<Object> channel,
                                                 @GloopParameter(allowNull=false)
                                                 Object key,
                                                 @GloopParameter(allowNull=false)
                                                 Range<? extends Number> range,
                                                 @GloopParameter(allowNull=false)
                                                 Limit limit,
                                                 GloopExecutionContext context)

Asynchronously stream over a range of members in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every value

key - the key

range - the range

limit - the limit

Returns:

long count of elements in the specified range.

Since:

4.3

zrevrangebyscoreWithScores

@GloopParameter(name="redisZrevrangebyscoreWithScoresOutput")
public static List<ScoredValue<Object>> zrevrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                                                   String connectionName,
                                                                   @GloopParameter(allowNull=false)
                                                                   Object key,
                                                                   @GloopParameter(allowNull=false)
                                                                   Range<? extends Number> range,
                                                                   GloopExecutionContext context)

Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

List<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreWithScores

@GloopParameter(name="redisZrevrangebyscoreWithScoresOutput")
public static List<ScoredValue<Object>> zrevrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                                                   String connectionName,
                                                                   @GloopParameter(allowNull=false)
                                                                   Object key,
                                                                   @GloopParameter(allowNull=false)
                                                                   Range<? extends Number> range,
                                                                   @GloopParameter(allowNull=false)
                                                                   Limit limit,
                                                                   GloopExecutionContext context)

Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - limit

Returns:

List<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreWithScores

@GloopParameter(name="redisZrevrangebyscoreWithScoresOutput")
public static Long zrevrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                              String connectionName,
                                              @GloopParameter(allowNull=false)
                                              ScoredValueStreamingChannel<Object> channel,
                                              @GloopParameter(allowNull=false)
                                              Object key,
                                              @GloopParameter(allowNull=false)
                                              Range<? extends Number> range,
                                              GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

Returns:

Long count of elements in the specified range.

zrevrangebyscoreWithScores

@GloopParameter(name="redisZrevrangebyscoreWithScoresOutput")
public static Long zrevrangebyscoreWithScores(@GloopParameter(allowNull=false)
                                              String connectionName,
                                              @GloopParameter(allowNull=false)
                                              ScoredValueStreamingChannel<Object> channel,
                                              @GloopParameter(allowNull=false)
                                              Object key,
                                              @GloopParameter(allowNull=false)
                                              Range<? extends Number> range,
                                              @GloopParameter(allowNull=false)
                                              Limit limit,
                                              GloopExecutionContext context)

Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

limit - the limit

Returns:

Long count of elements in the specified range.

Since:

4.3

zrevrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrevrangebyscoreWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrevrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                                                String connectionName,
                                                                                @GloopParameter(allowNull=false)
                                                                                Object key,
                                                                                @GloopParameter(allowNull=false)
                                                                                Range<? extends Number> range,
                                                                                GloopExecutionContext context)

Asynchronously return a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

Returns:

list<ScoredValue<V>> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrevrangebyscoreWithScoresOutput")
public static Future<List<ScoredValue<Object>>> zrevrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                                                String connectionName,
                                                                                @GloopParameter(allowNull=false)
                                                                                Object key,
                                                                                @GloopParameter(allowNull=false)
                                                                                Range<? extends Number> range,
                                                                                @GloopParameter(allowNull=false)
                                                                                Limit limit,
                                                                                GloopExecutionContext context)

Asynchronously return a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

range - the range

limit - limit

Returns:

list<V> array-reply list of elements in the specified score range.

Since:

4.3

zrevrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrevrangebyscoreWithScoresOutput")
public static Future<Long> zrevrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                           String connectionName,
                                                           @GloopParameter(allowNull=false)
                                                           ScoredValueStreamingChannel<Object> channel,
                                                           @GloopParameter(allowNull=false)
                                                           Object key,
                                                           @GloopParameter(allowNull=false)
                                                           Range<? extends Number> range,
                                                           GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

Returns:

long count of elements in the specified range.

zrevrangebyscoreWithScoresAsync

@GloopParameter(name="redisFutureZrevrangebyscoreWithScoresOutput")
public static Future<Long> zrevrangebyscoreWithScoresAsync(@GloopParameter(allowNull=false)
                                                           String connectionName,
                                                           @GloopParameter(allowNull=false)
                                                           ScoredValueStreamingChannel<Object> channel,
                                                           @GloopParameter(allowNull=false)
                                                           Object key,
                                                           @GloopParameter(allowNull=false)
                                                           Range<? extends Number> range,
                                                           @GloopParameter(allowNull=false)
                                                           Limit limit,
                                                           GloopExecutionContext context)

Asynchronously stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

range - the range

limit - the limit

Returns:

long count of elements in the specified range.

Since:

4.3

zrevrank

@GloopParameter(name="redisZrevrankOutput")
public static Long zrevrank(@GloopParameter(allowNull=false)
                            String connectionName,
                            @GloopParameter(allowNull=false)
                            Object key,
                            @GloopParameter(allowNull=false)
                            Object member,
                            GloopExecutionContext context)

Determine the index of a member in a sorted set, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

Long integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,

zrevrankAsync

@GloopParameter(name="redisFutureZrevrankOutput")
public static Future<Long> zrevrankAsync(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         Object key,
                                         @GloopParameter(allowNull=false)
                                         Object member,
                                         GloopExecutionContext context)

Asynchronously determine the index of a member in a sorted set, with scores ordered from high to low.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

long integer-reply the rank of member. if member does not exist in the sorted set or key does not exist,

zscan

@GloopParameter(name="redisZscanOutput")
public static ScoredValueScanCursor<Object> zscan(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

ScoredValueScanCursor<V> scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static ScoredValueScanCursor<Object> zscan(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanArgs scanArgs,
                                                  GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanArgs - scan arguments

Returns:

ScoredValueScanCursor<V> scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static ScoredValueScanCursor<Object> zscan(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanCursor scanCursor,
                                                  @GloopParameter(allowNull=false)
                                                  ScanArgs scanArgs,
                                                  GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

scanArgs - scan arguments

Returns:

ScoredValueScanCursor<V> scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static ScoredValueScanCursor<Object> zscan(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanCursor scanCursor,
                                                  GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

Returns:

ScoredValueScanCursor<V> scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static StreamScanCursor zscan(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ScoredValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

Returns:

StreamScanCursor scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static StreamScanCursor zscan(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ScoredValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ScanArgs scanArgs,
                                     GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanArgs - scan arguments

Returns:

StreamScanCursor scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static StreamScanCursor zscan(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ScoredValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ScanCursor scanCursor,
                                     @GloopParameter(allowNull=false)
                                     ScanArgs scanArgs,
                                     GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

scanArgs - scan arguments

Returns:

StreamScanCursor scan cursor.

zscan

@GloopParameter(name="redisZscanOutput")
public static StreamScanCursor zscan(@GloopParameter(allowNull=false)
                                     String connectionName,
                                     @GloopParameter(allowNull=false)
                                     ScoredValueStreamingChannel<Object> channel,
                                     @GloopParameter(allowNull=false)
                                     Object key,
                                     @GloopParameter(allowNull=false)
                                     ScanCursor scanCursor,
                                     GloopExecutionContext context)

Incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

Returns:

StreamScanCursor scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<ScoredValueScanCursor<Object>> zscanAsync(@GloopParameter(allowNull=false)
                                                               String connectionName,
                                                               @GloopParameter(allowNull=false)
                                                               Object key,
                                                               GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

Returns:

scoredValueScanCursor<V> scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<ScoredValueScanCursor<Object>> zscanAsync(@GloopParameter(allowNull=false)
                                                               String connectionName,
                                                               @GloopParameter(allowNull=false)
                                                               Object key,
                                                               @GloopParameter(allowNull=false)
                                                               ScanArgs scanArgs,
                                                               GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanArgs - scan arguments

Returns:

scoredValueScanCursor<V> scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<ScoredValueScanCursor<Object>> zscanAsync(@GloopParameter(allowNull=false)
                                                               String connectionName,
                                                               @GloopParameter(allowNull=false)
                                                               Object key,
                                                               @GloopParameter(allowNull=false)
                                                               ScanCursor scanCursor,
                                                               @GloopParameter(allowNull=false)
                                                               ScanArgs scanArgs,
                                                               GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

scanArgs - scan arguments

Returns:

scoredValueScanCursor<V> scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<ScoredValueScanCursor<Object>> zscanAsync(@GloopParameter(allowNull=false)
                                                               String connectionName,
                                                               @GloopParameter(allowNull=false)
                                                               Object key,
                                                               @GloopParameter(allowNull=false)
                                                               ScanCursor scanCursor,
                                                               GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

Returns:

scoredValueScanCursor<V> scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<StreamScanCursor> zscanAsync(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  ScoredValueStreamingChannel<Object> channel,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

Returns:

streamScanCursor scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<StreamScanCursor> zscanAsync(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  ScoredValueStreamingChannel<Object> channel,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanArgs scanArgs,
                                                  GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanArgs - scan arguments

Returns:

streamScanCursor scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<StreamScanCursor> zscanAsync(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  ScoredValueStreamingChannel<Object> channel,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanCursor scanCursor,
                                                  @GloopParameter(allowNull=false)
                                                  ScanArgs scanArgs,
                                                  GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

scanArgs - scan arguments

Returns:

streamScanCursor scan cursor.

zscanAsync

@GloopParameter(name="redisFutureZscanOutput")
public static Future<StreamScanCursor> zscanAsync(@GloopParameter(allowNull=false)
                                                  String connectionName,
                                                  @GloopParameter(allowNull=false)
                                                  ScoredValueStreamingChannel<Object> channel,
                                                  @GloopParameter(allowNull=false)
                                                  Object key,
                                                  @GloopParameter(allowNull=false)
                                                  ScanCursor scanCursor,
                                                  GloopExecutionContext context)

Asynchronously incrementally iterate sorted sets elements and associated scores.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

channel - streaming channel that receives a call for every scored value

key - the key

scanCursor - cursor to resume from a previous scan, must not be null

Returns:

streamScanCursor scan cursor.

zscore

@GloopParameter(name="redisZscoreOutput")
public static Double zscore(@GloopParameter(allowNull=false)
                            String connectionName,
                            @GloopParameter(allowNull=false)
                            Object key,
                            @GloopParameter(allowNull=false)
                            Object member,
                            GloopExecutionContext context)

Get the score associated with the given member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

Double bulk-string-reply the score of member (a double precision floating point number), represented as string.

zscoreAsync

@GloopParameter(name="redisFutureZscoreOutput")
public static Future<Double> zscoreAsync(@GloopParameter(allowNull=false)
                                         String connectionName,
                                         @GloopParameter(allowNull=false)
                                         Object key,
                                         @GloopParameter(allowNull=false)
                                         Object member,
                                         GloopExecutionContext context)

Asynchronously get the score associated with the given member in a sorted set.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

key - the key

member - the member type: value

Returns:

double bulk-string-reply the score of member (a double precision floating point number), represented as string.

zunionstore

@GloopParameter(name="redisZunionstoreOutput")
public static Long zunionstore(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object destination,
                               GloopExecutionContext context,
                               @GloopParameter(allowNull=false)
                               Object... keys)

Add multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - destination key

keys - source keys

Returns:

Long integer-reply the number of elements in the resulting sorted set at destination.

zunionstore

@GloopParameter(name="redisZunionstoreOutput")
public static Long zunionstore(@GloopParameter(allowNull=false)
                               String connectionName,
                               @GloopParameter(allowNull=false)
                               Object destination,
                               @GloopParameter(allowNull=false)
                               ZStoreArgs storeArgs,
                               GloopExecutionContext context,
                               @GloopParameter(allowNull=false)
                               Object... keys)

Add multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

storeArgs - the storeArgs

keys - the keys

Returns:

Long integer-reply the number of elements in the resulting sorted set at destination.

zunionstoreAsync

@GloopParameter(name="redisFutureZunionstoreOutput")
public static Future<Long> zunionstoreAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object destination,
                                            GloopExecutionContext context,
                                            @GloopParameter(allowNull=false)
                                            Object... keys)

Asynchronously add multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - destination key

keys - source keys

Returns:

long integer-reply the number of elements in the resulting sorted set at destination.

zunionstoreAsync

@GloopParameter(name="redisFutureZunionstoreOutput")
public static Future<Long> zunionstoreAsync(@GloopParameter(allowNull=false)
                                            String connectionName,
                                            @GloopParameter(allowNull=false)
                                            Object destination,
                                            @GloopParameter(allowNull=false)
                                            ZStoreArgs storeArgs,
                                            GloopExecutionContext context,
                                            @GloopParameter(allowNull=false)
                                            Object... keys)

Asynchronously add multiple sorted sets and store the resulting sorted set in a new key.

Parameters:

connectionName - The Martini Runtime Redis connection pool name

destination - the destination

storeArgs - the storeArgs

keys - the keys

Returns:

long integer-reply the number of elements in the resulting sorted set at destination.