Packages

trait SortedSetsApi extends ApiSubset

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SortedSetsApi
  2. ApiSubset
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type Field = RedisSerialization.Field
    Definition Classes
    ApiSubset
  2. type Key = RedisSerialization.Key
    Definition Classes
    ApiSubset
  3. type Record = RedisSerialization.Record
    Definition Classes
    ApiSubset
  4. abstract type Result[A]

    The type constructor into which a result of each command is wrapped.

    The type constructor into which a result of each command is wrapped. For example if Result is Future, then incr returns Future[Long].

    Definition Classes
    ApiSubset
  5. type Value = RedisSerialization.Value
    Definition Classes
    ApiSubset

Abstract Value Members

  1. abstract def execute[A](command: RedisCommand[A]): Result[A]
    Definition Classes
    ApiSubset
  2. abstract val serialization: RedisSerialization
    Definition Classes
    ApiSubset

Concrete Value Members

  1. def bzpopmax(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]

    Executes BZPOPMAX

  2. def bzpopmax(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]

    Executes BZPOPMAX

  3. def bzpopmin(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]

    Executes BZPOPMIN

  4. def bzpopmin(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]

    Executes BZPOPMIN

  5. def zadd(key: Key, memberScores: Iterable[(Value, Double)], existence: commons.OptArg[Boolean] = OptArg.Empty, changed: Boolean = false): Result[Int]

    Executes ZADD or simply returns 0 when memberScores is empty

  6. def zadd(key: Key, score: Double, members: Iterable[Value]): Result[Int]

    Executes ZADD or simply returns 0 when members is empty

  7. def zadd(key: Key, score: Double, member: Value, members: Value*): Result[Int]

    Executes ZADD

  8. def zadd(key: Key, member: Value, score: Double): Result[Boolean]

    Executes ZADD

  9. def zadd(key: Key, memberScore: (Value, Double), memberScores: (Value, Double)*): Result[Int]

    Executes ZADD

  10. def zaddIncr(key: Key, member: Value, score: Double, existence: commons.OptArg[Boolean] = OptArg.Empty): Result[commons.Opt[Double]]

    Executes ZADD

  11. def zcard(key: Key): Result[Long]

    Executes ZCARD

  12. def zcount(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]

    Executes ZCOUNT

  13. def zincrby(key: Key, increment: Double, member: Value): Result[Double]

    Executes ZINCRBY

  14. def zinterstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

    Executes ZINTERSTORE NOTE: keys MUST NOT be empty

  15. def zinterstore(destination: Key, key: Key, keys: Key*): Result[Long]

    Executes ZINTERSTORE

  16. def zinterstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

    Executes ZINTERSTORE NOTE: keysWeights MUST NOT be empty

  17. def zinterstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]

    Executes ZINTERSTORE

  18. def zlexcount(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]

    Executes ZLEXCOUNT

  19. def zpopmax(key: Key, count: Long): Result[Seq[(Value, Double)]]

    Executes ZPOPMAX

  20. def zpopmax(key: Key): Result[commons.Opt[(Value, Double)]]

    Executes ZPOPMAX

  21. def zpopmin(key: Key, count: Long): Result[Seq[(Value, Double)]]

    Executes ZPOPMIN

  22. def zpopmin(key: Key): Result[commons.Opt[(Value, Double)]]

    Executes ZPOPMIN]

  23. def zrange(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[Value]]

    Executes ZRANGE

  24. def zrangeWithscores(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[(Value, Double)]]

    Executes ZRANGE

  25. def zrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

    Executes ZRANGEBYLEX

  26. def zrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

    Executes ZRANGEBYSCORE

  27. def zrangebyscoreWithscores(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]

    Executes ZRANGEBYSCORE

  28. def zrank(key: Key, member: Value): Result[commons.Opt[Long]]

    Executes ZRANK

  29. def zrem(key: Key, members: Iterable[Value]): Result[Int]

    Executes ZREM or simply returns 0 when members is empty

  30. def zrem(key: Key, member: Value, members: Value*): Result[Int]

    Executes ZREM

  31. def zrem(key: Key, member: Value): Result[Boolean]

    Executes ZREM

  32. def zremrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]

    Executes ZREMRANGEBYLEX

  33. def zremrangebyrank(key: Key, start: Long = 0, stop: Long = -1): Result[Long]

    Executes ZREMRANGEBYRANK

  34. def zremrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]

    Executes ZREMRANGEBYSCORE

  35. def zrevrange(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[Value]]

    Executes ZREVRANGE

  36. def zrevrangeWithscores(key: Key, start: Long = 0, stop: Long = -1): Result[Seq[(Value, Double)]]

    Executes ZREVRANGE

  37. def zrevrangebylex(key: Key, max: LexLimit[Value] = LexLimit.PlusInf, min: LexLimit[Value] = LexLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

    Executes ZREVRANGEBYLEX

  38. def zrevrangebyscore(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

    Executes ZREVRANGEBYSCORE

  39. def zrevrangebyscoreWithscores(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]

    Executes ZREVRANGEBYSCORE

  40. def zrevrank(key: Key, member: Value): Result[commons.Opt[Long]]

    Executes ZREVRANK

  41. def zscan(key: Key, cursor: Cursor, matchPattern: commons.OptArg[Value] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[(Cursor, Seq[(Value, Double)])]

    Executes ZSCAN

  42. def zscore(key: Key, member: Value): Result[commons.Opt[Double]]

    Executes ZSCORE

  43. def zunionstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

    Executes ZUNIONSTORE NOTE: keys MUST NOT be empty

  44. def zunionstore(destination: Key, key: Key, keys: Key*): Result[Long]

    Executes ZUNIONSTORE

  45. def zunionstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

    Executes ZUNIONSTORE NOTE: keysWeights MUST NOT be empty

  46. def zunionstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]

    Executes ZUNIONSTORE