Packages

c

effredis.cluster

RedisClusterOps

abstract class RedisClusterOps[F[+_]] extends AnyRef

Self Type
RedisClusterClient[F]
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] toany2stringadd[RedisClusterOps[F]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (RedisClusterOps[F], B)
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F] toArrowAssoc[RedisClusterOps[F]] 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, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    appends the key value with the specified

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

    auths with the server.

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

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

  10. final def bitop(op: String, destKey: Any, srcKeys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Int]]]

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

  11. 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, SINGLE.type], F[Unit])]): F[Resp[Option[(K, V)]]]
  12. 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, SINGLE.type], F[Unit])]): F[Resp[Option[(K, V)]]]
  13. final def brpoplpush[A](srcKey: Any, dstKey: Any, timeoutInSeconds: Int)(implicit format: Format, parse: Parse[A], pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Option[A]]]
  14. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  15. final def dbsize(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Option[Long]]]

    returns the size of the db.

  16. final def decr(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    decrements the specified key by 1

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

    decrements the specified key by increment

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

    deletes the specified keys.

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

    test if the specified key exists.

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

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

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

    sets the expire time for the specified key.

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

    removes data from all the DB's.

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

    removes all the DB data.

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

    gets the value for the specified key.

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

    CONFIG GET

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

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

  36. final def getbit(key: Any, offset: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Int]]]

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

  37. final def getrange[A](key: Any, start: Int, end: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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).

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

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

  39. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  40. final def hdel(key: Any, field: Any, fields: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]
  41. final def hexists(key: Any, field: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Boolean]]
  42. final def hget[A](key: Any, field: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[A]]]
  43. final def hgetall1[K, V](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parseK: Parse[K], parseV: Parse[V]): F[Resp[Option[Map[K, V]]]]
  44. final def hincrby(key: Any, field: Any, value: Long)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]
  45. final def hincrbyfloat(key: Any, field: Any, value: Float)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Float]]]
  46. final def hkeys[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[List[A]]]]
  47. final def hlen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]
  48. final def hmget[K, V](key: Any, fields: K*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parseV: Parse[V]): F[Resp[Option[Map[K, V]]]]
  49. final def hmset(key: Any, map: Iterable[Product2[Any, Any]])(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Boolean]]

    Sets the specified fields to their respective values in the hash stored at key.

    Sets the specified fields to their respective values in the hash stored at key. This command overwrites any existing fields in the hash. If key does not exist, a new key holding a hash is created.

    map

    from fields to values

    returns

    True if operation completed successfully, False otherwise.

    See also

    HMSET documentation

  50. 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, SINGLE.type], F[Unit])]): F[Resp[Option[(Option[Int], Option[List[Option[A]]])]]]

    Incrementally iterate hash fields and associated values (since 2.8)

  51. final def hset1(key: Any, field: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    Sets field in the hash stored at key to value.

    Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

    returns

    Some(0) if field is a new field in the hash and value was set, Some(1) if field already exists in the hash and the value was updated.

    See also

    HSET documentation

  52. final def hsetnx(key: Any, field: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Boolean]]

    Sets field in the hash stored at key to value, only if field does not yet exist.

    Sets field in the hash stored at key to value, only if field does not yet exist. If key does not exist, a new key holding a hash is created. If field already exists, this operation has no effect.

    returns

    True if field is a new field in the hash and value was set. False if field exists in the hash and no operation was performed.

    See also

    HSETNX documentation

  53. final def hvals[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[List[A]]]]
  54. final def incr(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    increments the specified key by 1

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

    increments the specified key by increment

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

    returns all the keys matching the glob-style pattern.

  59. final def lindex[A](key: Any, index: Int)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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.

  60. final def llen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[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.

  61. final def lpop[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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

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

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

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

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

  64. final def lrange[A](key: Any, start: Int, end: Int)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], parse: Parse[A]): F[Resp[Option[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.

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

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

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

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

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

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

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

    get the values of all the specified keys.

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

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

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

    set the respective key value pairs.

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

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

    set the respective key value pairs.

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

  72. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  73. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  74. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  75. final def persist(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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).

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

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

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

    sets the expire timestamp in millis for the specified key.

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

    Add a value to the hyperloglog (>= 2.8.9)

  79. final def pfcount(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Option[Long]]]

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

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

    Merge existing keys (>= 2.8.9)

  81. final def ping(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Option[String]]]

    ping

  82. val pong: Option[String]
    Attributes
    protected
  83. final def psetex(key: Any, expiryInMillis: Long, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Boolean]]
  84. final def pttl(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

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

  85. final def quit(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Boolean]]

    exits the server.

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

    returns a randomly selected key from the currently selected DB.

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

    atomically renames the key oldkey to newkey.

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

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

  89. final def rpop[A](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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

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

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

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

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

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

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

  93. final def sadd(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[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)

  94. 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)

  95. final def scard(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

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

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

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

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

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

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

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

  99. final def set(key: Any, value: Any, whenSet: SetBehaviour = Always, expire: Duration = null, keepTTL: Boolean = false)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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.

  100. final def setConfig(key: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[String]]]

    CONFIG SET

  101. final def setbit(key: Any, offset: Int, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Int]]]

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

  102. final def setex(key: Any, expiry: Long, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Boolean]]
  103. final def setnx(key: Any, value: Any)(implicit format: Format, pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])]): F[Resp[Boolean]]

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

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

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

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

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

  106. final def sinterstore(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

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

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

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

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

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

    Return all the members of the Set value at key.

  109. final def smove(sourceKey: Any, destKey: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    Move the specified member from one Set to another atomically.

  110. 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, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[List[Option[A]]]]]

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

  111. 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, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[Long]]]

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

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

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

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

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

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

    Return multiple random elements from a Set (since 2.6)

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

    Return a random element from a Set

  116. final def srem(key: Any, value: Any, values: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[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)

  117. 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, SINGLE.type], F[Unit])]): F[Resp[Option[(Option[Int], Option[List[Option[A]]])]]]

    Incrementally iterate Set elements (since 2.8)

  118. final def strlen(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

    gets the length of the value associated with the key

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

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

  120. final def sunionstore(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[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

  121. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  122. final def time[A](implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parse: Parse[A]): F[Resp[Option[List[Option[A]]]]]

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

  123. def toString(): String
    Definition Classes
    AnyRef → Any
  124. final def ttl(key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Option[Long]]]

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

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

    Flushes all the previously watched keys for a transaction

  126. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  127. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  128. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  129. final def watch(key: Any, keys: Any*)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], 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. final def hgetall[K, V](key: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format, parseK: Parse[K], parseV: Parse[V]): F[Resp[Option[Map[K, V]]]]
    Annotations
    @deprecated
    Deprecated

    (Since version 3.2) Use the more idiomatic variant hgetall1, which has the returned Map behavior more consistent. See issue https://github.com/debasishg/scala-redis/issues/122

  3. final def hset(key: Any, field: Any, value: Any)(implicit pool: KeyPool[F, URI, (RedisClient[F, SINGLE.type], F[Unit])], format: Format): F[Resp[Boolean]]

    Sets field in the hash stored at key to value.

    Sets field in the hash stored at key to value. If key does not exist, a new key holding a hash is created. If field already exists in the hash, it is overwritten.

    returns

    True if field is a new field in the hash and value was set, False if field already exists in the hash and the value was updated.

    Deprecated

    return value semantics is inconsistent with effredis.HashOperations#hsetnx and effredis.HashOperations#hmset. Use effredis.HashOperations#hset1 instead

    See also

    HSET documentation

  4. def →[B](y: B): (RedisClusterOps[F], B)
    Implicit
    This member is added by an implicit conversion from RedisClusterOps[F] toArrowAssoc[RedisClusterOps[F]] 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] to any2stringadd[RedisClusterOps[F]]

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

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

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

Ungrouped