Packages

c

effredis.cluster

RedisClusterOps

abstract class RedisClusterOps[F[+_], M <: Mode] extends AnyRef

Self Type
RedisClusterClient[F, M]
Linear Supertypes
AnyRef, Any
Known Subclasses
RedisClusterClient
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RedisClusterOps
  2. AnyRef
  3. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new RedisClusterOps()(implicit arg0: Concurrent[F], arg1: ContextShift[F], arg2: Log[F], arg3: Timer[F])

Type Members

  1. abstract class E$F$RedisClusterOps extends AnyRef
    Attributes
    protected[this]

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toany2stringadd[RedisClusterOps[F, M]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (RedisClusterOps[F, M], B)
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toArrowAssoc[RedisClusterOps[F, M]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. final def append(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    appends the key value with the specified

  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. final def asking[A](implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]
  9. final def auth(secret: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    auths with the server.

  10. final def bitcount(key: Any, range: Option[(Int, Int)] = None)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Count the number of set bits in the given key within the optional range

  11. final def bitop(op: String, destKey: Any, srcKeys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

  12. final def blpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parse: Parse[V], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[(K, V)]]]
  13. final def brpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parse: Parse[V], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[(K, V)]]]
  14. final def brpoplpush[A](srcKey: Any, dstKey: Any, timeoutInSeconds: Int)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[A]]]
  15. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  16. final def dbsize(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Long]]

    returns the size of the db.

  17. final def decr(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    decrements the specified key by 1

  18. final def decrby(key: Any, increment: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    decrements the specified key by increment

  19. final def del(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    deletes the specified keys.

  20. def discard(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]
  21. final def echo(message: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[String]]
  22. def ensuring(cond: (RedisClusterOps[F, M]) => Boolean, msg: => Any): RedisClusterOps[F, M]
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toEnsuring[RedisClusterOps[F, M]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  23. def ensuring(cond: (RedisClusterOps[F, M]) => Boolean): RedisClusterOps[F, M]
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toEnsuring[RedisClusterOps[F, M]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  24. def ensuring(cond: Boolean, msg: => Any): RedisClusterOps[F, M]
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toEnsuring[RedisClusterOps[F, M]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  25. def ensuring(cond: Boolean): RedisClusterOps[F, M]
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toEnsuring[RedisClusterOps[F, M]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  26. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  28. def exec(hs: Seq[() => Any])(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[List[Any]]]]
  29. final def exists(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    test if the specified key exists.

  30. final def expire(key: Any, ttl: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    sets the expire time (in sec.) for the specified key.

  31. final def expireat(key: Any, timestamp: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    sets the expire time for the specified key.

  32. final def flushall(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[List[Resp[Boolean]]]

    removes data from all the DB's.

  33. final def flushdb(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[List[Resp[Boolean]]]

    removes all the DB data.

  34. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toStringFormat[RedisClusterOps[F, M]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  35. final def get[A](key: Any)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[A]]]

    gets the value for the specified key.

  36. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  37. final def getConfig(key: Any = "*")(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Option[Map[String, Option[String]]]]]

    CONFIG GET

  38. final def getType(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Option[String]]]

    returns the type of the value stored at key in form of a string.

  39. final def getbit(key: Any, offset: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Returns the bit value at offset in the string value stored at key

  40. final def getrange[A](key: Any, start: Int, end: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive).

  41. final def getset[A](key: Any, value: Any)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[A]]]

    is an atomic set this value and return the old value command.

  42. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  43. final def hdel(key: Any, field: Any, fields: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  44. final def hexists(key: Any, field: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]
  45. final def hget[A](key: Any, field: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]
  46. final def hgetall[K, V](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parseK: Parse[K], parseV: Parse[V]): F[Resp[Option[Map[K, V]]]]
  47. final def hincrby(key: Any, field: Any, value: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  48. final def hincrbyfloat(key: Any, field: Any, value: Float)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Option[Float]]]
  49. final def hkeys[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[List[Option[A]]]]
  50. final def hlen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  51. final def hmget[K, V](key: Any, fields: K*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parseV: Parse[V]): F[Resp[Map[K, Option[V]]]]
  52. final def hmset(key: Any, map: Iterable[Product2[Any, Any]])(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]
  53. final def hscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[(Int, List[Option[A]])]]]

    Incrementally iterate hash fields and associated values (since 2.8)

  54. final def hset(key: Any, map: Iterable[Product2[Any, Any]])(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  55. final def hset(key: Any, field: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  56. final def hsetnx(key: Any, field: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]
  57. final def hvals[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[List[Option[A]]]]
  58. final def incr(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    increments the specified key by 1

  59. final def incrby(key: Any, increment: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    increments the specified key by increment

  60. final def incrbyfloat(key: Any, increment: Float)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Option[Float]]]
  61. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  62. final def keys[A](pattern: Any = "*")(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[List[Option[A]]]]

    returns all the keys matching the glob-style pattern.

  63. final def lindex[A](key: Any, index: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    return the especified element of the list stored at the specified key.

    return the especified element of the list stored at the specified key. Negative indexes are supported, for example -1 is the last element, -2 the penultimate and so on.

  64. final def llen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    return the length of the list stored at the specified key.

    return the length of the list stored at the specified key. If the key does not exist zero is returned (the same behaviour as for empty lists). If the value stored at key is not a list an error is returned.

  65. final def lpop[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    atomically return and remove the first (LPOP) or last (RPOP) element of the list

  66. final def lpush(key: Any, value: Any, values: Any*)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Long]]

    add values to the head of the list stored at key (Variadic: >= 2.4)

  67. final def lpushx(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    add value to the head of the list stored at key (Variadic: >= 2.4)

  68. final def lrange[A](key: Any, start: Int, end: Int)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], parse: Parse[A]): F[Resp[List[Option[A]]]]

    return the specified elements of the list stored at the specified key.

    return the specified elements of the list stored at the specified key. Start and end are zero-based indexes.

  69. final def lrem(key: Any, count: Int, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Remove the first count occurrences of the value element from the list.

  70. final def lset(key: Any, index: Int, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    set the list element at index with the new Out of range indexes will generate an error

  71. final def ltrim(key: Any, start: Int, end: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Trim an existing list so that it will contain only the specified range of elements specified.

  72. final def mget[A](key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[List[Option[A]]]]

    get the values of all the specified keys.

  73. final def move(key: Any, db: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Move the specified key from the currently selected DB to the specified destination DB.

  74. final def mset(kvs: (Any, Any)*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    set the respective key value pairs.

    set the respective key value pairs. Overwrite value if key exists

  75. final def msetnx(kvs: (Any, Any)*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    set the respective key value pairs.

    set the respective key value pairs. Noop if any key exists

  76. def multi(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]
  77. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  78. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  79. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  80. final def persist(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

  81. final def pexpire(key: Any, ttlInMillis: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    sets the expire time (in milli sec.) for the specified key.

  82. final def pexpireat(key: Any, timestampInMillis: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    sets the expire timestamp in millis for the specified key.

  83. final def pfadd(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Long]]

    Add a value to the hyperloglog (>= 2.8.9)

  84. final def pfcount(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Long]]

    Get the estimated cardinality from one or more keys (>= 2.8.9)

  85. final def pfmerge(destination: Any, sources: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]

    Merge existing keys (>= 2.8.9)

  86. final def ping(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[List[Resp[String]]]

    ping

  87. val pong: Option[String]
    Attributes
    protected
  88. final def psetex(key: Any, expiryInMillis: Long, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]
  89. final def pttl(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    returns the remaining time to live of a key that has a timeout in millis

  90. final def quit(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]

    exits the server.

  91. final def randomkey[A](implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], parse: Parse[A]): F[Resp[Option[A]]]

    returns a randomly selected key from the currently selected DB.

  92. final def rename(oldkey: Any, newkey: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    atomically renames the key oldkey to newkey.

  93. final def renamenx(oldkey: Any, newkey: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    rename oldkey into newkey but fails if the destination key newkey already exists.

  94. def retryForAskRedirection[R](err: String, keys: List[String])(fn: (RedisClusterNode) => F[Resp[R]])(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[R]]

    Retry semantics for ASK redirection errors

    Retry semantics for ASK redirection errors

    err

    the error string

    fn

    the function to run

    returns

    the repsonse from redis server

  95. def retryForMovedRedirection[R](err: String, keys: List[String])(fn: (RedisClusterNode) => F[Resp[R]]): F[Resp[R]]

    Retry semantics for MOVED redirection errors

    Retry semantics for MOVED redirection errors

    err

    the error string

    fn

    the function to run

    returns

    the repsonse from redis server

  96. final def rpop[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    atomically return and remove the first (LPOP) or last (RPOP) element of the list

  97. final def rpoplpush[A](srcKey: Any, dstKey: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    Remove the first count occurrences of the value element from the list.

  98. final def rpush(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    add values to the tail of the list stored at key (Variadic: >= 2.4)

  99. final def rpushx(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    add value to the tail of the list stored at key (Variadic: >= 2.4)

  100. final def sadd(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Add the specified members to the set value stored at key.

    Add the specified members to the set value stored at key. (VARIADIC: >= 2.4)

  101. final def scan[A](cursor: Int, pattern: Any = "*", count: Int = 10): F[Resp[Option[(Option[Int], Option[List[Option[A]]])]]]

    Incrementally iterate the keys space (since 2.8)

  102. final def scard(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Return the number of elements (the cardinality) of the Set at key.

  103. final def sdiff[A](key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Set[Option[A]]]]

    Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN.

  104. final def sdiffstore(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Compute the difference between the Set key1 and all the Sets key2, ..., keyN, and store the resulting Set at dstkey.

  105. final def select(index: Int): F[Resp[Boolean]]

    selects the DB to connect, defaults to 0 (zero).

  106. final def set(key: Any, value: Any, whenSet: SetBehaviour = Always, expire: Duration = null, keepTTL: Boolean = false)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    sets the key with the specified value.

    sets the key with the specified value. Starting with Redis 2.6.12 SET supports a set of options that modify its behavior:

    NX -- Only set the key if it does not already exist. XX -- Only set the key if it already exist. PX milliseconds -- Set the specified expire time, in milliseconds.

  107. final def setConfig(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    CONFIG SET

  108. final def setbit(key: Any, offset: Int, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Sets or clears the bit at offset in the string value stored at key

  109. final def setex(key: Any, expiry: Long, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]
  110. final def setnx(key: Any, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Boolean]]

    sets the value for the specified key, only if the key is not there.

  111. final def setrange(key: Any, offset: Int, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    SETRANGE key offset value Overwrites part of the string stored at key, starting at the specified offset, for the entire length of

  112. final def sinter[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Set[Option[A]]]]

    Return the intersection between the Sets stored at key1, key2, ..., keyN.

  113. final def sinterstore(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]
  114. final def sismember(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Test if the specified value is a member of the Set at key.

  115. final def smembers[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Set[Option[A]]]]

    Return all the members of the Set value at key.

  116. final def smove(sourceKey: Any, destKey: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Move the specified member from one Set to another atomically.

  117. final def sort[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[List[Option[A]]]]

    sort keys in a set, and optionally pull values for them

  118. final def sortNStore[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil, storeAt: String)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Long]]

    sort keys in a set, and stores result in the supplied key

  119. final def spop[A](key: Any, count: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Set[Option[A]]]]

    Remove and return multiple random elements (pop) from the Set value at key since (3.2).

  120. final def spop[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    Remove and return (pop) a random element from the Set value at key.

  121. final def srandmember[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Set[Option[A]]]]

    Return multiple random elements from a Set (since 2.6)

  122. final def srandmember[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]

    Return a random element from a Set

  123. final def srem(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Remove the specified members from the set value stored at key.

    Remove the specified members from the set value stored at key. (VARIADIC: >= 2.4)

  124. final def sscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Option[(Int, List[Option[A]])]]]

    Incrementally iterate Set elements (since 2.8)

  125. final def strlen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    gets the length of the value associated with the key

  126. final def sunion[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[Set[Option[A]]]]

    Return the union between the Sets stored at key1, key2, ..., keyN.

  127. final def sunionstore(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    Compute the union between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

    Compute the union between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey. SUNIONSTORE returns the size of the union, unlike what the documentation says refer http://code.google.com/p/redis/issues/detail?id=121

  128. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  129. final def time(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[Resp[List[Option[Long]]]]

    returns the current server time as a two items lists: a Unix timestamp and the amount of microseconds already elapsed in the current second.

  130. def toString(): String
    Definition Classes
    AnyRef → Any
  131. final def ttl(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Long]]

    returns the remaining time to live of a key that has a timeout

  132. final def unwatch(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])]): F[List[Resp[Boolean]]]

    Flushes all the previously watched keys for a transaction

  133. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  134. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  135. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  136. final def watch(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, M], F[Unit])], format: Format): F[Resp[Boolean]]

    Marks the given keys to be watched for conditional execution of a transaction.

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated
  2. def →[B](y: B): (RedisClusterOps[F, M], B)
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F, M] toArrowAssoc[RedisClusterOps[F, M]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromRedisClusterOps[F, M] to any2stringadd[RedisClusterOps[F, M]]

Inherited by implicit conversion StringFormat fromRedisClusterOps[F, M] to StringFormat[RedisClusterOps[F, M]]

Inherited by implicit conversion Ensuring fromRedisClusterOps[F, M] to Ensuring[RedisClusterOps[F, M]]

Inherited by implicit conversion ArrowAssoc fromRedisClusterOps[F, M] to ArrowAssoc[RedisClusterOps[F, M]]

Ungrouped