RedisCluster

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val POINTS_PER_SERVER: Int

def addServer(server: ClusterNode): Try[Unit]

add server to internal pool

def append(key: Any, value: Any)(implicit format: Format): Option[Long]

appends the key value with the specified value.

final def asInstanceOf[T0]: T0

def auth(secret: Any)(implicit format: Format): Boolean

auths with the server.

def bgrewriteaof: Boolean

def bgsave: Boolean

save the DB in the background.

def bitcount(key: Any, range: Option[(Int, Int)])(implicit format: Format): Option[Int]

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

def bitop(op: String, destKey: Any, srcKeys: Any*)(implicit format: Format): Option[Int]

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

def blpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpoplpush[A](srcKey: Any, dstKey: Any, timeoutInSeconds: Int)(implicit format: Format, parse: Parse[A]): Option[A]

val clients: List[IdentifiableRedisClientPool]

def clone(): AnyRef

def close(): Unit

def dbsize: Option[Long]

returns the size of the db.

def decr(key: Any)(implicit format: Format): Option[Long]

decrements the specified key by 1

def decrby(key: Any, increment: Long)(implicit format: Format): Option[Long]

decrements the specified key by increment

def del(key: Any, keys: Any*)(implicit format: Format): Option[Long]

deletes the specified keys.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalInt(luaCode: String, keys: List[Any], args: List[Any]): Option[Int]

def evalMultiBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

evaluates lua code on the server.

def evalMultiSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def evalSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalSHABulk[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def exists(key: Any)(implicit format: Format): Boolean

test if the specified key exists.

def expire(key: Any, ttl: Int)(implicit format: Format): Boolean

sets the expire time (in sec.

def expireat(key: Any, timestamp: Long)(implicit format: Format): Boolean

sets the expire time for the specified key.

def finalize(): Unit

def flushall: Boolean

removes data from all the DB's.

def flushdb: Boolean

removes all the DB data.

def get[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

gets the value for the specified key.

final def getClass(): Class[_]

def getConfig(key: Any)(implicit format: Format): Option[Map[String, Option[String]]]

CONFIG GET

def getType(key: Any)(implicit format: Format): Option[String]

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

def getbit(key: Any, offset: Int)(implicit format: Format): Option[Int]

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

def getrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[A]

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

def getset[A](key: Any, value: Any)(implicit format: Format, parse: Parse[A]): Option[A]

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

def hashCode(): Int

def hdel(key: Any, field: Any, fields: Any*)(implicit format: Format): Option[Long]

def hexists(key: Any, field: Any)(implicit format: Format): Boolean

def hget[A](key: Any, field: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def hgetall[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hgetall1[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hincrby(key: Any, field: Any, value: Long)(implicit format: Format): Option[Long]

def hincrbyfloat(key: Any, field: Any, value: Float)(implicit format: Format): Option[Float]

def hkeys[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def hlen(key: Any)(implicit format: Format): Option[Long]

def hmget[K, V](key: Any, fields: K*)(implicit format: Format, parseV: Parse[V]): Option[Map[K, V]]

def hmset(key: Any, map: Iterable[Product2[Any, Any]])(implicit format: Format): Boolean

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

val hosts: List[ClusterNode]

val hr: HashRing[IdentifiableRedisClientPool]

def hscan[A](key: Any, cursor: Int, pattern: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate hash fields and associated values (since 2.

def hset1(key: Any, field: Any, value: Any)(implicit format: Format): Option[Long]

Sets field in the hash stored at key to value.

def hsetnx(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

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

def hvals[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def inSameNode[T](keys: Any*)(body: (RedisClient) ⇒ T)(implicit format: Format): T

def incr(key: Any)(implicit format: Format): Option[Long]

increments the specified key by 1

def incrby(key: Any, increment: Long)(implicit format: Format): Option[Long]

increments the specified key by increment

def incrbyfloat(key: Any, increment: Float)(implicit format: Format): Option[Float]

def info: Option[String]

The info command returns different information and statistics about the server.

final def isInstanceOf[T0]: Boolean

val keyTag: Option[KeyTag]

def keys[A](pattern: Any)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

returns all the keys matching the glob-style pattern.

def lastsave: Option[Long]

return the UNIX TIME of the last DB SAVE executed with success.

def lindex[A](key: Any, index: Int)(implicit format: Format, parse: Parse[A]): Option[A]

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

def listServers: List[ClusterNode]

list all running servers

def llen(key: Any)(implicit format: Format): Option[Long]

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

def lpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

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

def lpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

add values to the head of the list stored at key (Variadic: >= 2.

def lpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

add value to the head of the list stored at key (Variadic: >= 2.

def lrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

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

def lrem(key: Any, count: Int, value: Any)(implicit format: Format): Option[Long]

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

def lset(key: Any, index: Int, value: Any)(implicit format: Format): Boolean

set the list element at index with the new value.

def ltrim(key: Any, start: Int, end: Int)(implicit format: Format): Boolean

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

def mget[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

get the values of all the specified keys.

def monitor: Boolean

is a debugging command that outputs the whole sequence of commands received by the Redis server.

def move(key: Any, db: Int)(implicit format: Format): Boolean

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

def mset(kvs: (Any, Any)*)(implicit format: Format): Boolean

set the respective key value pairs.

def msetnx(kvs: (Any, Any)*)(implicit format: Format): Boolean

set the respective key value pairs.

final def ne(arg0: AnyRef): Boolean

def nodeForKey(key: Any)(implicit format: Format): IdentifiableRedisClientPool

get node for the key

final def notify(): Unit

final def notifyAll(): Unit

def onAllConns[T](body: (RedisClient) ⇒ T): Iterable[T]

def oneCommonAnswerOr[A](r: Iterable[A])(moreResultHandler: (Iterable[A]) ⇒ Option[A]): Option[A]

def persist(key: Any)(implicit format: Format): 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).

def pexpire(key: Any, ttlInMillis: Int)(implicit format: Format): Boolean

sets the expire time (in milli sec.

def pexpireat(key: Any, timestampInMillis: Long)(implicit format: Format): Boolean

sets the expire timestamp in millis for the specified key.

def ping: Option[String]

ping

val pong: Option[String]

def processForKey[T](key: Any)(body: (RedisCommand) ⇒ T)(implicit format: Format): T

def processForKeys[T](keys: List[Any])(body: (List[Any]) ⇒ (RedisCommand) ⇒ T)(implicit format: Format): Iterable[T]

def psetex(key: Any, expiryInMillis: Long, value: Any)(implicit format: Format): Boolean

def pttl(key: Any)(implicit format: Format): Option[Long]

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

def quit: Boolean

exits the server.

val r: Random

def randomNode(): RedisClientPool

def randomkey[A](implicit parse: Parse[A]): Option[A]

returns a randomly selected key from the currently selected DB.

def removeServer(nodename: String): Unit

remove a server

def rename(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

atomically renames the key oldkey to newkey.

def renamenx(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

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

def replaceServer(server: ClusterNode): Unit

replace a server very useful when you want to replace a server in test mode to one in production mode

def rpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

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

def rpoplpush[A](srcKey: Any, dstKey: Any)(implicit format: Format, parse: Parse[A]): Option[A]

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

def rpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

add values to the tail of the list stored at key (Variadic: >= 2.

def rpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

add value to the tail of the list stored at key (Variadic: >= 2.

def sadd(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

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

def save: Boolean

save the DB on disk now.

def scan[A](cursor: Int, pattern: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate the keys space (since 2.

def scard(key: Any)(implicit format: Format): Option[Long]

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

def scriptExists(shahash: String): Option[Int]

def scriptFlush: Option[String]

def scriptLoad(luaCode: String): Option[String]

def sdiff[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

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

def sdiffstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the difference between the Set key1 and all the Sets key2, .

def select(index: Int): Boolean

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

def set(key: Any, value: Any, whenSet: SetBehaviour = Always, expire: Duration = null)(implicit format: Format): Boolean

sets the key with the specified value.

def setConfig(key: Any, value: Any)(implicit format: Format): Option[String]

CONFIG SET

def setbit(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Int]

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

def setex(key: Any, expiry: Long, value: Any)(implicit format: Format): Boolean

def setnx(key: Any, value: Any)(implicit format: Format): Boolean

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

def setrange(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Long]

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

def shutdown: Boolean

Stop all the clients, save the DB, then quit the server.

def sinter[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

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

def sinterstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the intersection between the Sets stored at key1, key2, .

def sismember(key: Any, value: Any)(implicit format: Format): Boolean

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

def slaveof(options: Any): Boolean

The SLAVEOF command can change the replication settings of a slave on the fly.

def smembers[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Return all the members of the Set value at key.

def smove(sourceKey: Any, destKey: Any, value: Any)(implicit format: Format): Option[Long]

Move the specified member from one Set to another atomically.

def sort[A](key: String, limit: Option[(Int, Int)], desc: Boolean, alpha: Boolean, by: Option[String], get: List[String])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

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

def sortNStore[A](key: String, limit: Option[(Int, Int)], desc: Boolean, alpha: Boolean, by: Option[String], get: List[String], storeAt: String)(implicit format: Format, parse: Parse[A]): Option[Long]

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

def spop[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

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

def spop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

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

def srandmember[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

Return multiple random elements from a Set (since 2.

def srandmember[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

Return a random element from a Set

def srem(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

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

def sscan[A](key: Any, cursor: Int, pattern: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate Set elements (since 2.

def strlen(key: Any)(implicit format: Format): Option[Long]

gets the length of the value associated with the key

def sunion[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

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

def sunionstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the union between the Sets stored at key1, key2, .

final def synchronized[T0](arg0: ⇒ T0): T0

def time[A](implicit format: Format, parse: Parse[A]): 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.

def toString(): String

def ttl(key: Any)(implicit format: Format): Option[Long]

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

def unwatch(): Boolean

Flushes all the previously watched keys for a transaction

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def watch(key: Any, keys: Any*)(implicit format: Format): Boolean

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

def zadd(key: Any, score: Double, member: Any, scoreVals: (Double, Any)*)(implicit format: Format): Option[Long]

Add the specified members having the specified score to the sorted set stored at key.

def zcard(key: Any)(implicit format: Format): Option[Long]

def zcount(key: Any, min: Double = Double.NegativeInfinity, max: Double = Double.PositiveInfinity, minInclusive: Boolean = true, maxInclusive: Boolean = true)(implicit format: Format): Option[Long]

def zincrby(key: Any, incr: Double, member: Any)(implicit format: Format): Option[Double]

def zinterstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zinterstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zrange[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangeWithScore[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrangebylex[A](key: Any, min: String, max: String, limit: Option[(Int, Int)])(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscoreWithScore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrank(key: Any, member: Any, reverse: Boolean = false)(implicit format: Format): Option[Long]

def zrem(key: Any, member: Any, members: Any*)(implicit format: Format): Option[Long]

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

def zremrangebyrank(key: Any, start: Int = 0, end: Int = 1)(implicit format: Format): Option[Long]

def zremrangebyscore(key: Any, start: Double = Double.NegativeInfinity, end: Double = Double.PositiveInfinity)(implicit format: Format): Option[Long]

def zscan[A](key: Any, cursor: Int, pattern: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate sorted sets elements and associated scores (since 2.

def zscore(key: Any, element: Any)(implicit format: Format): Option[Double]

def zunionstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zunionstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def hset(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

Sets field in the hash stored at key to value.

def set(key: Any, value: Any, onlyIfExists: Boolean, time: SecondsOrMillis): Boolean