Package org.springframework.data.redis.core

Interface ReactiveZSetOperations<K,V>

public interface ReactiveZSetOperations<K,V>
Reactive Redis operations for Sorted (ZSet) Commands.

Streams of methods returning Mono<K> or Flux<M> are terminated with InvalidDataAccessApiUsageException when RedisElementReader.read(ByteBuffer) returns null for a particular element as Reactive Streams prohibit the usage of null values.

Since:
2.0
Author:
Mark Paluch, Christoph Strobl, Andrey Shlykov
See Also:

  • Method Details

    • add

      reactor.core.publisher.Mono<Boolean> add(K key, V value, double score)
      Add value to a sorted set at key, or update its score if it already exists.
      Parameters:
      key - must not be null.
      value - the value.
      score - the score.
      Returns:
      See Also:

    • addAll

      reactor.core.publisher.Mono<Long> addAll(K key, Collection<? extends ZSetOperations.TypedTuple<V>> tuples)
      Add tuples to a sorted set at key, or update their score if it already exists.
      Parameters:
      key - must not be null.
      tuples - the score.
      Returns:
      See Also:

    • remove

      reactor.core.publisher.Mono<Long> remove(K key, Object... values)
      Remove values from sorted set. Return number of removed elements.
      Parameters:
      key - must not be null.
      values - must not be null.
      Returns:
      See Also:

    • incrementScore

      reactor.core.publisher.Mono<Double> incrementScore(K key, V value, double delta)
      Increment the score of element with value in sorted set by increment.
      Parameters:
      key - must not be null.
      value - the value.
      delta - the delta to add. Can be negative.
      Returns:
      See Also:

    • randomMember

      reactor.core.publisher.Mono<V> randomMember(K key)
      Get random element from set at key.
      Parameters:
      key - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • distinctRandomMembers

      reactor.core.publisher.Flux<V> distinctRandomMembers(K key, long count)
      Get count distinct random elements from set at key.
      Parameters:
      key - must not be null.
      count - number of members to return.
      Returns:
      Throws:
      IllegalArgumentException - if count is negative.
      Since:
      2.6
      See Also:

    • randomMembers

      reactor.core.publisher.Flux<V> randomMembers(K key, long count)
      Get count random elements from set at key.
      Parameters:
      key - must not be null.
      count - number of members to return.
      Returns:
      Throws:
      IllegalArgumentException - if count is negative.
      Since:
      2.6
      See Also:

    • randomMemberWithScore

      reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> randomMemberWithScore(K key)
      Get random element with its score from set at key.
      Parameters:
      key - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • distinctRandomMembersWithScore

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> distinctRandomMembersWithScore(K key, long count)
      Get count distinct random elements with their score from set at key.
      Parameters:
      key - must not be null.
      count - number of members to return.
      Returns:
      Throws:
      IllegalArgumentException - if count is negative.
      Since:
      2.6
      See Also:

    • randomMembersWithScore

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> randomMembersWithScore(K key, long count)
      Get count random elements with their score from set at key.
      Parameters:
      key - must not be null.
      count - number of members to return.
      Returns:
      Throws:
      IllegalArgumentException - if count is negative.
      Since:
      2.6
      See Also:

    • rank

      reactor.core.publisher.Mono<Long> rank(K key, Object o)
      Determine the index of element with value in a sorted set.
      Parameters:
      key - must not be null.
      o - the value.
      Returns:
      See Also:

    • reverseRank

      reactor.core.publisher.Mono<Long> reverseRank(K key, Object o)
      Determine the index of element with value in a sorted set when scored high to low.
      Parameters:
      key - must not be null.
      o - the value.
      Returns:
      See Also:

    • range

      reactor.core.publisher.Flux<V> range(K key, Range<Long> range)
      Get elements between start and end from sorted set.
      Parameters:
      key - must not be null.
      range - must not be null.
      Returns:
      See Also:

    • rangeWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeWithScores(K key, Range<Long> range)
      Get set of Tuples between start and end from sorted set.
      Parameters:
      key - must not be null.
      range - must not be null.
      Returns:
      See Also:

    • rangeByScore

      reactor.core.publisher.Flux<V> rangeByScore(K key, Range<Double> range)
      Get elements where score is between min and max from sorted set.
      Parameters:
      key - must not be null.
      range - must not be null.
      Returns:
      See Also:

    • rangeByScoreWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range)
      Get set of Tuples where score is between min and max from sorted set.
      Parameters:
      key - must not be null.
      range - must not be null.
      Returns:
      See Also:

    • rangeByScore

      reactor.core.publisher.Flux<V> rangeByScore(K key, Range<Double> range, Limit limit)
      Get elements in range from start to end where score is between min and max from sorted set.
      Parameters:
      key - must not be null.
      range -
      limit -
      Returns:
      See Also:

    • rangeByScoreWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K key, Range<Double> range, Limit limit)
      Get set of Tuples in range from start to end where score is between min and max from sorted set.
      Parameters:
      key -
      range -
      limit -
      Returns:
      See Also:

    • reverseRange

      reactor.core.publisher.Flux<V> reverseRange(K key, Range<Long> range)
      Get elements in range from start to end from sorted set ordered from high to low.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • reverseRangeWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K key, Range<Long> range)
      Get set of Tuples in range from start to end from sorted set ordered from high to low.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • reverseRangeByScore

      reactor.core.publisher.Flux<V> reverseRangeByScore(K key, Range<Double> range)
      Get elements where score is between min and max from sorted set ordered from high to low.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • reverseRangeByScoreWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range)
      Get set of Tuple where score is between min and max from sorted set ordered from high to low.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • reverseRangeByScore

      reactor.core.publisher.Flux<V> reverseRangeByScore(K key, Range<Double> range, Limit limit)
      Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
      Parameters:
      key - must not be null.
      range -
      limit -
      Returns:
      See Also:

    • reverseRangeByScoreWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K key, Range<Double> range, Limit limit)
      Get set of Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
      Parameters:
      key - must not be null.
      range -
      limit -
      Returns:
      See Also:

    • rangeAndStoreByLex

      default reactor.core.publisher.Mono<Long> rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)
      Store all elements at dstKey with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • rangeAndStoreByLex

      reactor.core.publisher.Mono<Long> rangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)
      Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      limit - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • reverseRangeAndStoreByLex

      default reactor.core.publisher.Mono<Long> reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range)
      Store all elements at dstKey with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • reverseRangeAndStoreByLex

      reactor.core.publisher.Mono<Long> reverseRangeAndStoreByLex(K srcKey, K dstKey, Range<String> range, Limit limit)
      Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at srcKey with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      limit - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • rangeAndStoreByScore

      @Nullable default reactor.core.publisher.Mono<Long> rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)
      Store all elements at dstKey with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • rangeAndStoreByScore

      reactor.core.publisher.Mono<Long> rangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)
      Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      limit - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • reverseRangeAndStoreByScore

      default reactor.core.publisher.Mono<Long> reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range)
      Store all elements at dstKey with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • reverseRangeAndStoreByScore

      reactor.core.publisher.Mono<Long> reverseRangeAndStoreByScore(K srcKey, K dstKey, Range<Double> range, Limit limit)
      Store n elements at dstKey, where n = Limit.getCount(), starting at Limit.getOffset() with reverse ordering by score from ZSET at srcKey with a score between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      srcKey - must not be null.
      dstKey - must not be null.
      range - must not be null.
      limit - must not be null.
      Returns:
      the number of stored elements.
      Since:
      3.0
      See Also:

    • scan

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> scan(K key)
      Use a Flux to iterate over entries in the sorted set at key. The resulting Flux acts as a cursor and issues ZSCAN commands itself as long as the subscriber signals demand.
      Parameters:
      key - must not be null.
      Returns:
      the Flux emitting the values one by one or an empty Flux if none exist.
      Throws:
      IllegalArgumentException - when given key is null.
      Since:
      2.1
      See Also:

    • scan

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> scan(K key, ScanOptions options)
      Use a Flux to iterate over entries in the sorted set at key given ScanOptions. The resulting Flux acts as a cursor and issues ZSCAN commands itself as long as the subscriber signals demand.
      Parameters:
      key - must not be null.
      options - must not be null. Use ScanOptions.NONE instead.
      Returns:
      the Flux emitting the values one by one or an empty Flux if none exist.
      Throws:
      IllegalArgumentException - when one of the required arguments is null.
      Since:
      2.1
      See Also:

    • count

      reactor.core.publisher.Mono<Long> count(K key, Range<Double> range)
      Count number of elements within sorted set with scores between min and max.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • lexCount

      reactor.core.publisher.Mono<Long> lexCount(K key, Range<String> range)
      Count number of elements within sorted set with a value between Range.getLowerBound() and Range.getUpperBound() applying lexicographical ordering.
      Parameters:
      key - must not be null.
      range - must not be null
      Returns:
      Since:
      2.4
      See Also:

    • popMin

      reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMin(K key)
      Remove and return the value with its score having the lowest score from sorted set at key.
      Parameters:
      key - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • popMin

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> popMin(K key, long count)
      Remove and return count values with their score having the lowest score from sorted set at key.
      Parameters:
      key - must not be null.
      count - number of elements to pop.
      Returns:
      Since:
      2.6
      See Also:

    • popMin

      reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMin(K key, Duration timeout)
      Remove and return the value with its score having the lowest score from sorted set at key.
      Parameters:
      key - must not be null.
      timeout - maximal duration to wait until an entry in the list at key is available. Must be either Duration.ZERO or greater {@link 1 second}, must not be null. A timeout of zero can be used to wait indefinitely. Durations between zero and one second are not supported.
      Returns:
      Since:
      2.6
      See Also:

    • popMax

      reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMax(K key)
      Remove and return the value with its score having the highest score from sorted set at key.
      Parameters:
      key - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • popMax

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> popMax(K key, long count)
      Remove and return count values with their score having the highest score from sorted set at key.
      Parameters:
      key - must not be null.
      count - number of elements to pop.
      Returns:
      Since:
      2.6
      See Also:

    • popMax

      reactor.core.publisher.Mono<ZSetOperations.TypedTuple<V>> popMax(K key, Duration timeout)
      Remove and return the value with its score having the highest score from sorted set at key.
      Parameters:
      key - must not be null.
      timeout - maximal duration to wait until an entry in the list at key is available. Must be either Duration.ZERO or greater {@link 1 second}, must not be null. A timeout of zero can be used to wait indefinitely. Durations between zero and one second are not supported.
      Returns:
      Since:
      2.6
      See Also:

    • size

      reactor.core.publisher.Mono<Long> size(K key)
      Returns the number of elements of the sorted set stored with given key.
      Parameters:
      key -
      Returns:
      See Also:

    • score

      reactor.core.publisher.Mono<Double> score(K key, Object o)
      Get the score of element with value from sorted set with key key.
      Parameters:
      key - must not be null.
      o - the value.
      Returns:
      See Also:

    • score

      reactor.core.publisher.Mono<List<Double>> score(K key, Object... o)
      Get the scores of elements with values from sorted set with key key.
      Parameters:
      key - must not be null.
      o - the values.
      Returns:
      Since:
      2.6
      See Also:

    • removeRange

      reactor.core.publisher.Mono<Long> removeRange(K key, Range<Long> range)
      Remove elements in range between start and end from sorted set with key.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • removeRangeByLex

      reactor.core.publisher.Mono<Long> removeRangeByLex(K key, Range<String> range)
      Remove elements in range from sorted set with key.
      Parameters:
      key - must not be null.
      range - must not be null.
      Returns:
      a Mono emitting the number or removed elements.
      Since:
      2.5
      See Also:

    • removeRangeByScore

      reactor.core.publisher.Mono<Long> removeRangeByScore(K key, Range<Double> range)
      Remove elements with scores between min and max from sorted set with key.
      Parameters:
      key - must not be null.
      range -
      Returns:
      See Also:

    • difference

      default reactor.core.publisher.Flux<V> difference(K key, K otherKey)
      Diff sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • difference

      reactor.core.publisher.Flux<V> difference(K key, Collection<K> otherKeys)
      Diff sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • differenceWithScores

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, K otherKey)
      Diff sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • differenceWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> differenceWithScores(K key, Collection<K> otherKeys)
      Diff sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • differenceAndStore

      default reactor.core.publisher.Mono<Long> differenceAndStore(K key, K otherKey, K destKey)
      Diff sorted sets and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      destKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • differenceAndStore

      reactor.core.publisher.Mono<Long> differenceAndStore(K key, Collection<K> otherKeys, K destKey)
      Diff sorted sets and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersect

      default reactor.core.publisher.Flux<V> intersect(K key, K otherKey)
      Intersect sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersect

      reactor.core.publisher.Flux<V> intersect(K key, Collection<K> otherKeys)
      Intersect sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersectWithScores

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, K otherKey)
      Intersect sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersectWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys)
      Intersect sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersectWithScores

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)
      Intersect sorted sets at key and otherKeys .
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      aggregate - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersectWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> intersectWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)
      Intersect sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      aggregate - must not be null.
      weights - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • intersectAndStore

      default reactor.core.publisher.Mono<Long> intersectAndStore(K key, K otherKey, K destKey)
      Intersect sorted sets at key and otherKey and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      destKey - must not be null.
      Returns:
      See Also:

    • intersectAndStore

      reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey)
      Intersect sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      Returns:
      See Also:

    • intersectAndStore

      default reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)
      Intersect sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      aggregate - must not be null.
      Returns:
      Since:
      2.1
      See Also:

    • intersectAndStore

      reactor.core.publisher.Mono<Long> intersectAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)
      Intersect sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      aggregate - must not be null.
      weights - must not be null.
      Returns:
      Since:
      2.1
      See Also:

    • union

      default reactor.core.publisher.Flux<V> union(K key, K otherKey)
      Union sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • union

      reactor.core.publisher.Flux<V> union(K key, Collection<K> otherKeys)
      Union sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • unionWithScores

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, K otherKey)
      Union sorted sets.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • unionWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys)
      Union sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • unionWithScores

      default reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate)
      Union sorted sets at key and otherKeys .
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      aggregate - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • unionWithScores

      reactor.core.publisher.Flux<ZSetOperations.TypedTuple<V>> unionWithScores(K key, Collection<K> otherKeys, Aggregate aggregate, Weights weights)
      Union sorted sets.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      aggregate - must not be null.
      weights - must not be null.
      Returns:
      Since:
      2.6
      See Also:

    • unionAndStore

      reactor.core.publisher.Mono<Long> unionAndStore(K key, K otherKey, K destKey)
      Union sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKey - must not be null.
      destKey - must not be null.
      Returns:
      See Also:

    • unionAndStore

      reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey)
      Union sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      Returns:
      See Also:

    • unionAndStore

      default reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)
      Union sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      aggregate - must not be null.
      Returns:
      Since:
      2.1
      See Also:

    • unionAndStore

      reactor.core.publisher.Mono<Long> unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)
      Union sorted sets at key and otherKeys and store result in destination destKey.
      Parameters:
      key - must not be null.
      otherKeys - must not be null.
      destKey - must not be null.
      aggregate - must not be null.
      weights - must not be null.
      Returns:
      Since:
      2.1
      See Also:

    • rangeByLex

      reactor.core.publisher.Flux<V> rangeByLex(K key, Range<String> range)
      Get all elements with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      key - must not be null.
      range - must not be null.
      See Also:

    • rangeByLex

      reactor.core.publisher.Flux<V> rangeByLex(K key, Range<String> range, Limit limit)
      Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      key - must not be null
      range - must not be null.
      limit - can be null.
      Returns:
      See Also:

    • reverseRangeByLex

      reactor.core.publisher.Flux<V> reverseRangeByLex(K key, Range<String> range)
      Get all elements with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      key - must not be null.
      range - must not be null.
      See Also:

    • reverseRangeByLex

      reactor.core.publisher.Flux<V> reverseRangeByLex(K key, Range<String> range, Limit limit)
      Get all elements n elements, where n = Limit.getCount(), starting at Limit.getOffset() with reverse lexicographical ordering from ZSET at key with a value between Range.getLowerBound() and Range.getUpperBound().
      Parameters:
      key - must not be null
      range - must not be null.
      limit - can be null.
      Returns:
      See Also:

    • delete

      reactor.core.publisher.Mono<Boolean> delete(K key)
      Removes the given key.
      Parameters:
      key - must not be null.